Showing preview only (6,978K chars total). Download the full file or copy to clipboard to get everything.
Repository: rschurade/Ingnomia
Branch: master
Commit: 5676b6ffc105
Files: 489
Total size: 6.6 MB
Directory structure:
gitextract_k1kbwdwj/
├── .clang-format
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── cmake.yml
│ └── docs.yml
├── .gitignore
├── .gitmodules
├── 3rdparty/
│ ├── CMakeLists.txt
│ ├── NoesisApp/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── pch.h
│ │ └── register.cpp
│ ├── exprtk/
│ │ ├── CMakeLists.txt
│ │ ├── exprtk.cpp
│ │ ├── exprtk.hpp
│ │ └── license/
│ │ └── license.json
│ └── fastnoise/
│ ├── CMakeLists.txt
│ ├── FastNoise.cpp
│ ├── FastNoise.h
│ ├── LICENSE
│ └── README.md
├── CMakeLists.txt
├── Changelog.md
├── LICENSE
├── README.md
├── cmake/
│ └── modules/
│ ├── FindBugSplat.cmake
│ ├── FindNoesis.cmake
│ ├── FindOpenAL.cmake
│ ├── FindSteam.cmake
│ └── windeployqt.cmake
├── content/
│ ├── CMakeLists.txt
│ ├── JSON/
│ │ ├── config.json
│ │ ├── embarkpresets.json
│ │ ├── menusettings.json
│ │ ├── newgame.json
│ │ └── profs.json
│ ├── ai/
│ │ ├── animal_big.xml
│ │ ├── animal_guard_dog.xml
│ │ ├── animal_hunter.xml
│ │ ├── animal_nighthunter.xml
│ │ ├── animal_small_pasture.xml
│ │ ├── animal_standard.xml
│ │ ├── automaton_mark1.xml
│ │ ├── automaton_mark2.xml
│ │ ├── egg.xml
│ │ ├── gnome_standard.xml
│ │ ├── gnome_trader.xml
│ │ ├── monster_mant_queen.xml
│ │ ├── monster_mant_soldier.xml
│ │ ├── monster_mant_worker.xml
│ │ └── monster_standard.xml
│ ├── db/
│ │ └── ingnomia.db.sql
│ ├── shaders/
│ │ ├── axle_f.glsl
│ │ ├── axle_v.glsl
│ │ ├── selection_f.glsl
│ │ ├── selection_v.glsl
│ │ ├── thoughtbubble_f.glsl
│ │ ├── thoughtbubble_v.glsl
│ │ ├── world_f.glsl
│ │ ├── world_v.glsl
│ │ └── worldupdate_c.glsl
│ └── xaml/
│ ├── Agriculture.xaml
│ ├── CreatureInfo.xaml
│ ├── DebugGui.xaml
│ ├── Fonts/
│ │ └── SIL Open Font License.txt
│ ├── GameGui.xaml
│ ├── IngamePage.xaml
│ ├── InventoryGui.xaml
│ ├── LoadGamePage.xaml
│ ├── Main.xaml
│ ├── MainMenu.xaml
│ ├── MainPage.xaml
│ ├── MilitaryGui.xaml
│ ├── Neighbors.xaml
│ ├── NewGamePage.xaml
│ ├── PopulationWindow.xaml
│ ├── SelectionGui.xaml
│ ├── SettingsPage.xaml
│ ├── StockpileGui.xaml
│ ├── Theme/
│ │ ├── Fonts/
│ │ │ ├── PT Root UI_Bold.otf
│ │ │ └── PT Root UI_Regular.otf
│ │ ├── NoesisTheme.Brushes.DarkAqua.xaml
│ │ ├── NoesisTheme.Brushes.DarkBlue.xaml
│ │ ├── NoesisTheme.Brushes.DarkCrimson.xaml
│ │ ├── NoesisTheme.Brushes.DarkEmerald.xaml
│ │ ├── NoesisTheme.Brushes.DarkGreen.xaml
│ │ ├── NoesisTheme.Brushes.DarkLime.xaml
│ │ ├── NoesisTheme.Brushes.DarkOrange.xaml
│ │ ├── NoesisTheme.Brushes.DarkPurple.xaml
│ │ ├── NoesisTheme.Brushes.DarkRed.xaml
│ │ ├── NoesisTheme.Brushes.LightAqua.xaml
│ │ ├── NoesisTheme.Brushes.LightBlue.xaml
│ │ ├── NoesisTheme.Brushes.LightCrimson.xaml
│ │ ├── NoesisTheme.Brushes.LightEmerald.xaml
│ │ ├── NoesisTheme.Brushes.LightGreen.xaml
│ │ ├── NoesisTheme.Brushes.LightLime.xaml
│ │ ├── NoesisTheme.Brushes.LightOrange.xaml
│ │ ├── NoesisTheme.Brushes.LightPurple.xaml
│ │ ├── NoesisTheme.Brushes.LightRed.xaml
│ │ ├── NoesisTheme.Colors.Dark.xaml
│ │ ├── NoesisTheme.Colors.Light.xaml
│ │ ├── NoesisTheme.DarkAqua.xaml
│ │ ├── NoesisTheme.DarkBlue.xaml
│ │ ├── NoesisTheme.DarkCrimson.xaml
│ │ ├── NoesisTheme.DarkEmerald.xaml
│ │ ├── NoesisTheme.DarkGreen.xaml
│ │ ├── NoesisTheme.DarkLime.xaml
│ │ ├── NoesisTheme.DarkOrange.xaml
│ │ ├── NoesisTheme.DarkPurple.xaml
│ │ ├── NoesisTheme.DarkRed.xaml
│ │ ├── NoesisTheme.Fonts.xaml
│ │ ├── NoesisTheme.LightAqua.xaml
│ │ ├── NoesisTheme.LightBlue.xaml
│ │ ├── NoesisTheme.LightCrimson.xaml
│ │ ├── NoesisTheme.LightEmerald.xaml
│ │ ├── NoesisTheme.LightGreen.xaml
│ │ ├── NoesisTheme.LightLime.xaml
│ │ ├── NoesisTheme.LightOrange.xaml
│ │ ├── NoesisTheme.LightPurple.xaml
│ │ ├── NoesisTheme.LightRed.xaml
│ │ └── NoesisTheme.Styles.xaml
│ ├── TileInfo.xaml
│ ├── WaitPage.xaml
│ ├── WorkshopGui.xaml
│ ├── localization/
│ │ ├── _.xaml
│ │ ├── en_US.xaml
│ │ ├── fr_FR.xaml
│ │ └── pt_BR.xaml
│ └── styles/
│ ├── colors.xaml
│ └── mainmenu/
│ ├── pageswap.xaml
│ └── styles.xaml
├── devmessages.txt
├── docs/
│ ├── Pipfile
│ ├── generate.py
│ └── lib/
│ ├── __init__.py
│ ├── db.py
│ ├── material.py
│ ├── render.py
│ ├── sprites/
│ │ ├── __init__.py
│ │ ├── layout.py
│ │ ├── render.py
│ │ └── sprite.py
│ ├── store.py
│ ├── themes/
│ │ ├── __init__.py
│ │ └── default/
│ │ ├── __init__.py
│ │ ├── assets/
│ │ │ ├── doc.js
│ │ │ └── style.css
│ │ ├── sprites.py
│ │ ├── templates/
│ │ │ ├── base.html.j2
│ │ │ ├── constructions.html.j2
│ │ │ ├── food.html.j2
│ │ │ ├── index.html.j2
│ │ │ ├── item.html.j2
│ │ │ ├── items.html.j2
│ │ │ ├── macros.html.j2
│ │ │ ├── navtable.html.j2
│ │ │ ├── plants.html.j2
│ │ │ ├── sprites.css.j2
│ │ │ ├── tints.svg.j2
│ │ │ ├── workshop.html.j2
│ │ │ └── workshops.html.j2
│ │ └── theme.py
│ └── util.py
├── gui/
│ ├── SampleData/
│ │ ├── GameModelSampleData.xaml
│ │ ├── StockpileModelSampleData.xaml
│ │ └── ViewModelSampleData.xaml
│ ├── Src/
│ │ ├── App.config
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ └── stubs.cs
│ ├── app.config
│ └── gui.csproj
├── keybindings.json
├── resources/
│ └── Plants.docx
├── src/
│ ├── CMakeLists.txt
│ ├── base/
│ │ ├── PathFinderThread.cpp
│ │ ├── PathFinderThread.h
│ │ ├── behaviortree/
│ │ │ ├── bt_factory.cpp
│ │ │ ├── bt_factory.h
│ │ │ ├── bt_node.cpp
│ │ │ ├── bt_node.h
│ │ │ ├── bt_nodeaction.cpp
│ │ │ ├── bt_nodeaction.h
│ │ │ ├── bt_nodebbprecondition.cpp
│ │ │ ├── bt_nodebbprecondition.h
│ │ │ ├── bt_nodeconditional.cpp
│ │ │ ├── bt_nodeconditional.h
│ │ │ ├── bt_nodefallback.cpp
│ │ │ ├── bt_nodefallback.h
│ │ │ ├── bt_nodefallbackstar.cpp
│ │ │ ├── bt_nodefallbackstar.h
│ │ │ ├── bt_nodeforcefailure.cpp
│ │ │ ├── bt_nodeforcefailure.h
│ │ │ ├── bt_nodeforcesuccess.cpp
│ │ │ ├── bt_nodeforcesuccess.h
│ │ │ ├── bt_nodeinverter.cpp
│ │ │ ├── bt_nodeinverter.h
│ │ │ ├── bt_noderepeat.cpp
│ │ │ ├── bt_noderepeat.h
│ │ │ ├── bt_noderepeatuntilsuccess.cpp
│ │ │ ├── bt_noderepeatuntilsuccess.h
│ │ │ ├── bt_nodesequence.cpp
│ │ │ ├── bt_nodesequence.h
│ │ │ ├── bt_nodesequencestar.cpp
│ │ │ ├── bt_nodesequencestar.h
│ │ │ └── bt_tree.h
│ │ ├── config.cpp
│ │ ├── config.h
│ │ ├── counter.h
│ │ ├── crashhandler.cpp
│ │ ├── crashhandler.h
│ │ ├── db.cpp
│ │ ├── db.h
│ │ ├── dbhelper.cpp
│ │ ├── dbhelper.h
│ │ ├── dbstructs.h
│ │ ├── enums.h
│ │ ├── filter.cpp
│ │ ├── filter.h
│ │ ├── gamestate.cpp
│ │ ├── gamestate.h
│ │ ├── global.cpp
│ │ ├── global.h
│ │ ├── io.cpp
│ │ ├── io.h
│ │ ├── lightmap.cpp
│ │ ├── lightmap.h
│ │ ├── logger.cpp
│ │ ├── logger.h
│ │ ├── octree.cpp
│ │ ├── octree.h
│ │ ├── pathfinder.cpp
│ │ ├── pathfinder.h
│ │ ├── position.h
│ │ ├── priorityqueue.h
│ │ ├── region.cpp
│ │ ├── region.h
│ │ ├── regionmap.cpp
│ │ ├── regionmap.h
│ │ ├── selection.cpp
│ │ ├── selection.h
│ │ ├── tile.h
│ │ ├── util.cpp
│ │ ├── util.h
│ │ └── vptr.h
│ ├── game/
│ │ ├── anatomy.cpp
│ │ ├── anatomy.h
│ │ ├── animal.cpp
│ │ ├── animal.h
│ │ ├── automaton.cpp
│ │ ├── automaton.h
│ │ ├── canwork.cpp
│ │ ├── canwork.h
│ │ ├── creature.cpp
│ │ ├── creature.h
│ │ ├── creatureEquipment.cpp
│ │ ├── creaturefactory.cpp
│ │ ├── creaturefactory.h
│ │ ├── creaturemanager.cpp
│ │ ├── creaturemanager.h
│ │ ├── eventmanager.cpp
│ │ ├── eventmanager.h
│ │ ├── farm.cpp
│ │ ├── farm.h
│ │ ├── farmingmanager.cpp
│ │ ├── farmingmanager.h
│ │ ├── fluidmanager.cpp
│ │ ├── fluidmanager.h
│ │ ├── game.cpp
│ │ ├── game.h
│ │ ├── gamemanager.cpp
│ │ ├── gamemanager.h
│ │ ├── gnome.cpp
│ │ ├── gnome.h
│ │ ├── gnomeactions.cpp
│ │ ├── gnomeconditions.cpp
│ │ ├── gnomefactory.cpp
│ │ ├── gnomefactory.h
│ │ ├── gnomemanager.cpp
│ │ ├── gnomemanager.h
│ │ ├── gnometrader.cpp
│ │ ├── gnometrader.h
│ │ ├── grove.cpp
│ │ ├── grove.h
│ │ ├── inventory.cpp
│ │ ├── inventory.h
│ │ ├── item.cpp
│ │ ├── item.h
│ │ ├── itemhistory.cpp
│ │ ├── itemhistory.h
│ │ ├── job.cpp
│ │ ├── job.h
│ │ ├── jobmanager.cpp
│ │ ├── jobmanager.h
│ │ ├── mechanismmanager.cpp
│ │ ├── mechanismmanager.h
│ │ ├── militarymanager.cpp
│ │ ├── militarymanager.h
│ │ ├── monster.cpp
│ │ ├── monster.h
│ │ ├── neighbormanager.cpp
│ │ ├── neighbormanager.h
│ │ ├── newgamesettings.cpp
│ │ ├── newgamesettings.h
│ │ ├── object.cpp
│ │ ├── object.h
│ │ ├── pasture.cpp
│ │ ├── pasture.h
│ │ ├── plant.cpp
│ │ ├── plant.h
│ │ ├── room.cpp
│ │ ├── room.h
│ │ ├── roommanager.cpp
│ │ ├── roommanager.h
│ │ ├── soundmanager.cpp
│ │ ├── soundmanager.h
│ │ ├── stockpile.cpp
│ │ ├── stockpile.h
│ │ ├── stockpilemanager.cpp
│ │ ├── stockpilemanager.h
│ │ ├── techtree.cpp
│ │ ├── techtree.h
│ │ ├── workshop.cpp
│ │ ├── workshop.h
│ │ ├── workshopmanager.cpp
│ │ ├── workshopmanager.h
│ │ ├── world.cpp
│ │ ├── world.h
│ │ ├── worldconstructions.cpp
│ │ ├── worldgenerator.cpp
│ │ ├── worldgenerator.h
│ │ ├── worldgetters.cpp
│ │ ├── worldobject.cpp
│ │ └── worldobject.h
│ ├── gfx/
│ │ ├── sprite.cpp
│ │ ├── sprite.h
│ │ ├── spritefactory.cpp
│ │ └── spritefactory.h
│ ├── gui/
│ │ ├── aggregatoragri.cpp
│ │ ├── aggregatoragri.h
│ │ ├── aggregatorcreatureinfo.cpp
│ │ ├── aggregatorcreatureinfo.h
│ │ ├── aggregatordebug.cpp
│ │ ├── aggregatordebug.h
│ │ ├── aggregatorinventory.cpp
│ │ ├── aggregatorinventory.h
│ │ ├── aggregatorloadgame.cpp
│ │ ├── aggregatorloadgame.h
│ │ ├── aggregatormilitary.cpp
│ │ ├── aggregatormilitary.h
│ │ ├── aggregatorneighbors.cpp
│ │ ├── aggregatorneighbors.h
│ │ ├── aggregatorpopulation.cpp
│ │ ├── aggregatorpopulation.h
│ │ ├── aggregatorrenderer.cpp
│ │ ├── aggregatorrenderer.h
│ │ ├── aggregatorselection.cpp
│ │ ├── aggregatorselection.h
│ │ ├── aggregatorsettings.cpp
│ │ ├── aggregatorsettings.h
│ │ ├── aggregatorsound.cpp
│ │ ├── aggregatorsound.h
│ │ ├── aggregatorstockpile.cpp
│ │ ├── aggregatorstockpile.h
│ │ ├── aggregatortileinfo.cpp
│ │ ├── aggregatortileinfo.h
│ │ ├── aggregatorworkshop.cpp
│ │ ├── aggregatorworkshop.h
│ │ ├── eventconnector.cpp
│ │ ├── eventconnector.h
│ │ ├── keybindings.cpp
│ │ ├── keybindings.h
│ │ ├── license.h.in
│ │ ├── mainwindow.cpp
│ │ ├── mainwindow.h
│ │ ├── mainwindowrenderer.cpp
│ │ ├── mainwindowrenderer.h
│ │ ├── openalwrapper.cpp
│ │ ├── openalwrapper.h
│ │ ├── strings.cpp
│ │ ├── strings.h
│ │ └── xaml/
│ │ ├── GameGui.xaml.cpp
│ │ ├── GameGui.xaml.h
│ │ ├── GameModel.cpp
│ │ ├── GameModel.h
│ │ ├── IngamePage.xaml.cpp
│ │ ├── IngamePage.xaml.h
│ │ ├── LoadGameModel.cpp
│ │ ├── LoadGameModel.h
│ │ ├── LoadGamePage.xaml.cpp
│ │ ├── LoadGamePage.xaml.h
│ │ ├── Main.xaml.cpp
│ │ ├── Main.xaml.h
│ │ ├── MainMenu.xaml.cpp
│ │ ├── MainMenu.xaml.h
│ │ ├── MainPage.xaml.cpp
│ │ ├── MainPage.xaml.h
│ │ ├── NewGameModel.cpp
│ │ ├── NewGameModel.h
│ │ ├── NewGamePage.xaml.cpp
│ │ ├── NewGamePage.xaml.h
│ │ ├── Population.xaml.cpp
│ │ ├── Population.xaml.h
│ │ ├── PopulationModel.cpp
│ │ ├── PopulationModel.h
│ │ ├── ProxyGameView.cpp
│ │ ├── ProxyGameView.h
│ │ ├── ProxyMainView.cpp
│ │ ├── ProxyMainView.h
│ │ ├── ProxyTileInfo.cpp
│ │ ├── ProxyTileInfo.h
│ │ ├── SettingsModel.cpp
│ │ ├── SettingsModel.h
│ │ ├── SettingsPage.xaml.cpp
│ │ ├── SettingsPage.xaml.h
│ │ ├── StockpileModel.cpp
│ │ ├── StockpileModel.h
│ │ ├── StockpileProxy.cpp
│ │ ├── StockpileProxy.h
│ │ ├── TileInfo.xaml.cpp
│ │ ├── TileInfo.xaml.h
│ │ ├── TileInfoModel.cpp
│ │ ├── TileInfoModel.h
│ │ ├── ViewModel.cpp
│ │ ├── ViewModel.h
│ │ ├── WaitPage.xaml.cpp
│ │ ├── WaitPage.xaml.h
│ │ ├── agriculture.xaml.cpp
│ │ ├── agriculture.xaml.h
│ │ ├── agriculturemodel.cpp
│ │ ├── agriculturemodel.h
│ │ ├── agricultureproxy.cpp
│ │ ├── agricultureproxy.h
│ │ ├── converters.cpp
│ │ ├── converters.h
│ │ ├── creatureinfo.xaml.cpp
│ │ ├── creatureinfo.xaml.h
│ │ ├── creatureinfomodel.cpp
│ │ ├── creatureinfomodel.h
│ │ ├── creatureinfoproxy.cpp
│ │ ├── creatureinfoproxy.h
│ │ ├── debug.xaml.cpp
│ │ ├── debug.xaml.h
│ │ ├── debugmodel.cpp
│ │ ├── debugmodel.h
│ │ ├── debugproxy.cpp
│ │ ├── debugproxy.h
│ │ ├── inventory.xaml.cpp
│ │ ├── inventory.xaml.h
│ │ ├── inventorymodel.cpp
│ │ ├── inventorymodel.h
│ │ ├── inventoryproxy.cpp
│ │ ├── inventoryproxy.h
│ │ ├── loadgameproxy.cpp
│ │ ├── loadgameproxy.h
│ │ ├── military.xaml.cpp
│ │ ├── military.xaml.h
│ │ ├── militarymodel.cpp
│ │ ├── militarymodel.h
│ │ ├── militaryproxy.cpp
│ │ ├── militaryproxy.h
│ │ ├── neighbors.xaml.cpp
│ │ ├── neighbors.xaml.h
│ │ ├── neighborsmodel.cpp
│ │ ├── neighborsmodel.h
│ │ ├── neighborsproxy.cpp
│ │ ├── neighborsproxy.h
│ │ ├── populationproxy.cpp
│ │ ├── populationproxy.h
│ │ ├── selection.xaml.cpp
│ │ ├── selection.xaml.h
│ │ ├── selectionmodel.cpp
│ │ ├── selectionmodel.h
│ │ ├── selectionproxy.cpp
│ │ ├── selectionproxy.h
│ │ ├── settingsproxy.cpp
│ │ ├── settingsproxy.h
│ │ ├── stockpilegui.xaml.cpp
│ │ ├── stockpilegui.xaml.h
│ │ ├── workshopgui.xaml.cpp
│ │ ├── workshopgui.xaml.h
│ │ ├── workshopmodel.cpp
│ │ ├── workshopmodel.h
│ │ ├── workshopproxy.cpp
│ │ └── workshopproxy.h
│ ├── main.cpp
│ ├── pch.h
│ └── version.h.in
└── windows/
├── Ingnomia.manifest
├── Ingnomia.rc
└── resource.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
BasedOnStyle: Microsoft
AccessModifierOffset: '-4'
AlignAfterOpenBracket: AlwaysBreak
AlignConsecutiveAssignments: 'true'
AlignConsecutiveMacros: 'true'
BinPackArguments: 'true'
BinPackParameters: 'true'
BreakBeforeBraces: Allman
BreakConstructorInitializers: AfterColon
BreakInheritanceList: AfterColon
ColumnLimit: '0'
Cpp11BracedListStyle: 'false'
IncludeBlocks: 'Regroup'
IncludeCategories:
- Regex: '".*"'
Priority: 1
- Regex: '<N(oesi)?s[[:alnum:]._/]+>'
Priority: 2
- Regex: '<Q[[:alnum:]/]+>'
Priority: 3
- Regex: '<[[:alnum:_]]+>'
Priority: 4
- Regex: '<[[:alnum:]._]+\>'
Priority: 5
IndentCaseLabels: 'true'
IndentWidth: '4'
SortIncludes: 'true'
SpaceBeforeCpp11BracedList: 'true'
SpaceBeforeRangeBasedForLoopColon: 'true'
SpaceInEmptyParentheses: 'false'
SpacesInParentheses: 'true'
TabWidth: '4'
UseTab: ForContinuationAndIndentation
PointerAlignment: Left
...
================================================
FILE: .gitattributes
================================================
/src/gui/license.h
*.h diff=cpp
*.c diff=cpp
*.cpp diff=cpp
*.rc text=auto diff=cpp
================================================
FILE: .github/workflows/cmake.yml
================================================
name: CMake
on: [push, workflow_dispatch]
env:
# Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
BUILD_TYPE: RelWithDebInfo
jobs:
build:
# The CMake configure and build commands are platform agnostic and should work equally
# well on Windows or Mac. You can convert this to a matrix build if you need
# cross-platform coverage.
# See: https://docs.github.com/en/actions/configuring-and-managing-workflows/configuring-a-workflow#configuring-a-build-matrix
strategy:
fail-fast: false
matrix:
config:
- {
os: 'windows-2019',
sfml: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/SFML-2.5.1-windows-vc15-64-bit.zip',
noesis: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/NoesisGUI-NativeSDK-win-3.0.12.zip',
steam: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/steamworks_sdk_150.zip',
}
- {
os: 'ubuntu-18.04',
sfml: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/SFML-2.5.1-linux-gcc-64-bit.tar',
noesis: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/NoesisGUI-NativeSDK-linux-3.0.12.zip',
steam: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/steamworks_sdk_150.zip',
}
runs-on: ${{ matrix.config.os }}
steps:
- uses: actions/checkout@v2
- name: Get latest CMake
# Using 'latest' branch, the latest CMake is installed.
uses: lukka/get-cmake@latest
- name: Cache Qt
id: cache-qt
uses: actions/cache@v1
with:
path: '${{ github.workspace }}/Qt/'
key: ${{ runner.os }}-QtCache
- name: Install Qt
uses: jurplel/install-qt-action@v2
with:
version: '5.14.2'
dir: '${{ github.workspace }}/Qt/'
cached: ${{ steps.cache-qt.outputs.cache-hit }}
- name: Download Steam
uses: carlosperate/download-file-action@v1.0.3
id: download-steam
with:
file-url: ${{ matrix.config.steam }}
- name: Unpack Steam
uses: DuckSoft/extract-7z-action@v1.0
with:
pathSource: ${{ steps.download-steam.outputs.file-path }}
pathTarget: steamworks_sdk
- name: Download Noesis
uses: carlosperate/download-file-action@v1.0.3
id: download-noesis
with:
file-url: ${{ matrix.config.noesis }}
- name: Unpack Noesis
uses: DuckSoft/extract-7z-action@v1.0
with:
pathSource: ${{ steps.download-noesis.outputs.file-path }}
pathTarget: noesis_sdk
- name: Download BugSplat
uses: carlosperate/download-file-action@v1.0.3
id: download-bugsplat
with:
file-url: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/BugSplatNative.zip'
- name: Unpack BugSplat
uses: DuckSoft/extract-7z-action@v1.0
with:
pathSource: ${{ steps.download-bugsplat.outputs.file-path }}
pathTarget: bugsplat_sdk
- name: Install OpenAL Linux
if: (!startsWith(matrix.config.os, 'windows'))
shell: bash
run: sudo apt-get -yq install libopenal-dev
- name: Download OpenAL Windows
if: (startsWith(matrix.config.os, 'windows'))
uses: carlosperate/download-file-action@v1.0.3
id: download-openal
with:
file-url: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/openal.zip'
- name: Unpack OpenAL Windows
if: (startsWith(matrix.config.os, 'windows'))
uses: DuckSoft/extract-7z-action@v1.0
with:
pathSource: ${{ steps.download-openal.outputs.file-path }}
pathTarget: openal_sdk
- name: Download Tilesheets
uses: carlosperate/download-file-action@v1.0.3
id: download-tilesheet
with:
file-url: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/tilesheet.zip'
- name: Unpack Tilesheets
uses: DuckSoft/extract-7z-action@v1.0
with:
pathSource: ${{ steps.download-tilesheet.outputs.file-path }}
pathTarget: content
- name: Download Audio Files
uses: carlosperate/download-file-action@v1.0.3
id: download-audio
with:
file-url: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/audio.zip'
- name: Unpack Audio Files
uses: DuckSoft/extract-7z-action@v1.0
with:
pathSource: ${{ steps.download-audio.outputs.file-path }}
pathTarget: content
- name: Fix permissions
if: (!startsWith(matrix.config.os, 'windows'))
shell: bash
run: chmod +x ${{github.workspace}}/noesis_sdk/Src/Tools/Bin2h/bin2h.py
- name: Create Build Environment
run: cmake -E make_directory build
- name: Configure CMake
working-directory: ${{github.workspace}}/build
shell: bash
env:
NOESIS_LICENSE_KEY: ${{ secrets.NOESIS_LICENSE_KEY }}
NOESIS_LICENSE_NAME: ${{ secrets.NOESIS_LICENSE_NAME }}
BUGSPLAT_DB: ${{ secrets.BUGSPLAT_DB }}
run: |
cmake -S .. -B . -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_INSTALL_BINDIR="." -DSTEAM_SDK_ROOT=../steamworks_sdk/sdk -DNOESIS_ROOT=../noesis_sdk -DBUGSPLAT_SDK_ROOT=../bugsplat_sdk/bugsplat -DOPENAL_ROOT=../openal_sdk -DNOESIS_LICENSE_NAME="$NOESIS_LICENSE_NAME" -DNOESIS_LICENSE_KEY="$NOESIS_LICENSE_KEY" -DBUGSPLAT_DB="$BUGSPLAT_DB" -DGIT_REPO="${{github.repository}}" -DGIT_REF="${{github.ref}}" -DGIT_SHA="${{github.sha}}" -DBUILD_ID="${{github.run_id}}"
- name: Build
working-directory: ${{github.workspace}}/build
shell: bash
run: |
cmake --build . --config ${{env.BUILD_TYPE}} --target Ingnomia
- name: Install
working-directory: ${{github.workspace}}/build
shell: bash
run: |
cmake --install . --prefix ../install --config ${{env.BUILD_TYPE}}
- name: Find msbuild
if: (startsWith(matrix.config.os, 'windows'))
uses: microsoft/setup-msbuild@v1.0.2
id: msbuild
- name: Build Blend project
if: (startsWith(matrix.config.os, 'windows'))
working-directory: ${{github.workspace}}/gui
shell: pwsh
# Ignore errors for now
run: |
MSBuild.exe -t:restore gui.csproj
MSBuild.exe gui.csproj
- uses: actions/upload-artifact@v2
with:
name: "${{matrix.config.os}}-${{github.run_id}}"
path: |
install/
!**./*.iobj
!**./*.ipdb
================================================
FILE: .github/workflows/docs.yml
================================================
name: Docs
on:
push:
tags:
- '*'
workflow_dispatch:
jobs:
docs:
runs-on: ubuntu-latest
steps:
- uses: actions/setup-python@v2
with:
python-version: '3.9'
- uses: dschep/install-pipenv-action@v1
- uses: actions/checkout@v2
- name: Download Tilesheets
uses: carlosperate/download-file-action@v1.0.3
id: download-tilesheet
with:
file-url: 'https://github.com/rschurade/IngnomiaBuildDeps/raw/master/tilesheet.zip'
- name: Unpack Tilesheets
uses: DuckSoft/extract-7z-action@v1.0
with:
pathSource: ${{ steps.download-tilesheet.outputs.file-path }}
pathTarget: content
- name: Setup venv
working-directory: docs
run: |
pipenv install
- name: Generate docs
working-directory: docs
run: |
pipenv run ./generate.py --build ${GITHUB_REF#refs/*/}
- name: Deploy docs to gh-pages
uses: crazy-max/ghaction-github-pages@v2
with:
keep_history: true
build_dir: docs/html
fqdn: ${{ secrets.DOCS_DOMAIN }}
jekyll: false
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
================================================
FILE: .gitignore
================================================
# Created by https://www.gitignore.io/api/visualstudio
# Edit at https://www.gitignore.io/?templates=visualstudio
### VisualStudio ###
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
##
## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
# User-specific files
*.rsuser
*.suo
*.user
*.userosscache
*.sln.docstates
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
[Aa][Rr][Mm]/
[Aa][Rr][Mm]64/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
# Visual Studio 2015/2017 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/
# Visual Studio 2017 auto generated files
Generated\ Files/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUNIT
*.VisualState.xml
TestResult.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# Benchmark Results
BenchmarkDotNet.Artifacts/
# .NET Core
project.lock.json
project.fragment.lock.json
artifacts/
# StyleCop
StyleCopReport.xml
# Files built by Visual Studio
*_i.c
*_p.c
*_h.h
*.ilk
*.meta
*.obj
*.iobj
*.pch
*.pdb
*.ipdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*_wpftmp.csproj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
# Visual Studio Trace Files
*.e2e
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# JustCode is a .NET coding add-in
.JustCode
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# AxoCover is a Code Coverage Tool
.axoCover/*
!.axoCover/settings.json
# Visual Studio code coverage results
*.coverage
*.coveragexml
# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# Note: Comment the next line if you want to checkin your web deploy settings,
# but database connection strings (with potential passwords) will be unencrypted
*.pubxml
*.publishproj
# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/
# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/[Pp]ackages/*
# except build/, which is used as an MSBuild target.
!**/[Pp]ackages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/[Pp]ackages/repositories.config
# NuGet v3's project.json files produces more ignorable files
*.nuget.props
*.nuget.targets
# Microsoft Azure Build Output
csx/
*.build.csdef
# Microsoft Azure Emulator
ecf/
rcf/
# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt
*.appx
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!?*.[Cc]ache/
# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
orleans.codegen.cs
# Including strong name files can present a security risk
# (https://github.com/github/gitignore/pull/2483#issue-259490424)
#*.snk
# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/
# ASP.NET Core default setup: bower directory is configured as wwwroot/lib/ and bower restore is true
**/wwwroot/lib/
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
ServiceFabricBackup/
*.rptproj.bak
# SQL Server files
*.mdf
*.ldf
*.ndf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
*.rptproj.rsuser
# Microsoft Fakes
FakesAssemblies/
# GhostDoc plugin setting file
*.GhostDoc.xml
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
node_modules/
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
*.vbw
# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions
# Paket dependency manager
.paket/paket.exe
paket-files/
# FAKE - F# Make
.fake/
# JetBrains Rider
.idea/
*.sln.iml
# CodeRush personal settings
.cr/personal
# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc
# Cake - Uncomment if you are using it
# tools/**
# !tools/packages.config
# Tabs Studio
*.tss
# Telerik's JustMock configuration file
*.jmconfig
# BizTalk build output
*.btp.cs
*.btm.cs
*.odx.cs
*.xsd.cs
# OpenCover UI analysis results
OpenCover/
# Azure Stream Analytics local run output
ASALocalRun/
# MSBuild Binary and Structured Log
*.binlog
# NVidia Nsight GPU debugger configuration file
*.nvuser
# MFractors (Xamarin productivity tool) working folder
.mfractor/
# Local History for Visual Studio
.localhistory/
# BeatPulse healthcheck temp database
healthchecksdb
# End of https://www.gitignore.io/api/visualstudio
GeneratedFiles
/RetrofitMenuCreator/settings.ini
/spriteconv.json
/file
/src/gui/license.h
/src/version.h
/content/tilesheet
/content/db/ingnomia.db
# create by https://github.com/iamcco/coc-gitignore (Mon Aug 10 2020 12:20:22 GMT-0500 (hora estándar de Perú))
# CMake.gitignore:
CMakeLists.txt.user
CMakeCache.txt
CMakeFiles
CMakeScripts
Testing
Makefile
cmake_install.cmake
install_manifest.txt
compile_commands.json
CTestTestfile.cmake
_deps
# CMake.patch:
# External projects
*-prefix/
build/
/content/db/*.db
# Visual studio code
.vscode
# Doc
/docs/html
/content/audio
================================================
FILE: .gitmodules
================================================
[submodule "src/base/beehive"]
path = src/base/beehive
url = https://github.com/crust/beehive.git
================================================
FILE: 3rdparty/CMakeLists.txt
================================================
add_subdirectory(exprtk)
add_subdirectory(fastnoise)
add_subdirectory(NoesisApp)
set_target_properties(exprtk PROPERTIES FOLDER 3rdParty)
set_target_properties(fastnoise PROPERTIES FOLDER 3rdParty)
set_target_properties(NoesisApp PROPERTIES FOLDER 3rdParty)
================================================
FILE: 3rdparty/NoesisApp/CMakeLists.txt
================================================
project(NoesisApp)
add_library(${PROJECT_NAME})
# All used packages. Same list of packages must be added to register.cpp
set(NOESIS_APP_PACKAGES
App/ApplicationLauncher
App/DisplayLauncher
App/Display
App/Launcher
App/Providers
App/Theme
App/Interactivity
App/MediaElement
Render/GLRenderContext
Render/GLRenderDevice
Render/RenderContext
)
find_package(Noesis REQUIRED)
target_link_libraries(${PROJECT_NAME}
PUBLIC
Noesis
)
target_compile_definitions(
${PROJECT_NAME}
PUBLIC
NS_DEBUG
NS_PROFILE
NS_MINIMUM_LOG_LEVEL=0
PRIVATE
NS_APP_FRAMEWORK
)
target_precompile_headers(${PROJECT_NAME}
PRIVATE
pch.h
)
# Iterate over packages, and collect include + source directories
foreach(PACKAGE ${NOESIS_APP_PACKAGES})
set(PACKAGE_ROOT "${NOESIS_ROOT}/Src/Packages/${PACKAGE}")
set(INCLUDE_DIR "${PACKAGE_ROOT}/Include")
file(GLOB_RECURSE PKG_SRCS "${PACKAGE_ROOT}/*.cpp" "${PACKAGE_ROOT}/*.h")
file(GLOB_RECURSE PKG_RES "${PACKAGE_ROOT}/*.xaml" "${PACKAGE_ROOT}/*.ttf" "${PACKAGE_ROOT}/*.ttf" "${PACKAGE_ROOT}/*.otf")
list(APPEND NOESIS_APP_SRC ${PKG_SRCS})
list(APPEND NOESIS_APP_BIN2H ${PKG_RES})
if(EXISTS ${INCLUDE_DIR})
target_include_directories(${PROJECT_NAME}
PUBLIC
${INCLUDE_DIR}
)
string(REPLACE "/" ";" PACKAGE_SPLIT ${PACKAGE})
list(GET PACKAGE_SPLIT 0 PACKAGE_NAME)
list(GET PACKAGE_SPLIT 1 COMPONENT_NAME)
set(MAIN_INCLUDE ${INCLUDE_DIR}/Ns${PACKAGE_NAME}/${COMPONENT_NAME}.h)
if(EXISTS ${MAIN_INCLUDE})
target_precompile_headers(${PROJECT_NAME}
PRIVATE
${MAIN_INCLUDE}
)
endif()
endif()
# Switch package to static linkage
string(REPLACE "/" "_" PACKAGENAME ${PACKAGE})
string(TOUPPER ${PACKAGENAME} PACKAGENAME)
target_compile_definitions(${PROJECT_NAME}
PUBLIC
"NS_${PACKAGENAME}_API="
)
endforeach()
# Generated sources
if(UNIX)
set(BIN2H_EXE "${NOESIS_ROOT}/Src/Tools/Bin2h/bin2h.py")
elseif(WIN32)
set(BIN2H_EXE "${NOESIS_ROOT}/Src/Tools/Bin2h/bin2h.exe")
endif()
foreach(BIN2H_FILE ${NOESIS_APP_BIN2H})
get_filename_component(BASENAME ${BIN2H_FILE} NAME)
set(OUTPUTNAME "${BASENAME}.bin.h")
set(OUTPUTPATH "${CMAKE_CURRENT_BINARY_DIR}/${OUTPUTNAME}")
add_custom_command(
OUTPUT
${OUTPUTNAME}
COMMAND
${BIN2H_EXE} ${BIN2H_FILE} > ${OUTPUTPATH}
DEPENDS
${BIN2H_FILE}
)
list(APPEND NOESIS_APP_GENERATED_PATHS ${OUTPUTPATH})
endforeach()
target_include_directories(${PROJECT_NAME}
PRIVATE
${CMAKE_CURRENT_BINARY_DIR}
)
file(GLOB_RECURSE NOESIS_CORE_INCLUDES "${NOESIS_ROOT}/Include/*.h")
target_sources(${PROJECT_NAME}
PRIVATE
${NOESIS_APP_GENERATED_PATHS}
${NOESIS_APP_SRC}
${NOESIS_APP_BIN2H}
${NOESIS_CORE_INCLUDES}
pch.h
register.cpp
README.md
)
source_group(TREE "${CMAKE_CURRENT_BINARY_DIR}" PREFIX "Generated" FILES ${NOESIS_APP_GENERATED_PATHS})
source_group(TREE "${NOESIS_ROOT}/Src/Packages" PREFIX "NoesisApp" FILES ${NOESIS_APP_SRC})
source_group(TREE "${NOESIS_ROOT}/Src/Packages" PREFIX "Resources" FILES ${NOESIS_APP_BIN2H})
source_group(TREE "${NOESIS_ROOT}/Include" PREFIX "Core" FILES ${NOESIS_CORE_INCLUDES})
if(UNIX)
# NoesisApp requires several additional libraries on Linux
find_package(Threads REQUIRED)
find_package(OpenGL REQUIRED)
find_package(X11 REQUIRED)
target_link_libraries(${PROJECT_NAME}
PRIVATE
OpenGL::GL
Threads::Threads
${X11_LIBRARIES}
${CMAKE_DL_LIBS}
)
endif()
================================================
FILE: 3rdparty/NoesisApp/README.md
================================================
Do NOT add the source code here. Noesis is not under a license which would allow redistribution in source code form.
Provide NOESIS_ROOT to CMake and let the source be pulled in from there.
================================================
FILE: 3rdparty/NoesisApp/pch.h
================================================
#pragma once
#include <NoesisPCH.h>
================================================
FILE: 3rdparty/NoesisApp/register.cpp
================================================
////////////////////////////////////////////////////////////////////////////////////////////////////
// NoesisGUI - http://www.noesisengine.com
// Copyright (c) 2013 Noesis Technologies S.L. All Rights Reserved.
////////////////////////////////////////////////////////////////////////////////////////////////////
#include <NsCore/CompilerSettings.h>
#define PACKAGE_REGISTER(MODULE, PACKAGE) \
void NsRegisterReflection##MODULE##PACKAGE(); \
NsRegisterReflection##MODULE##PACKAGE()
#define PACKAGE_INIT(MODULE, PACKAGE) \
void NsInitPackage##MODULE##PACKAGE(); \
NsInitPackage##MODULE##PACKAGE()
#define PACKAGE_SHUTDOWN(MODULE, PACKAGE) \
void NsShutdownPackage##MODULE##PACKAGE(); \
NsShutdownPackage##MODULE##PACKAGE()
////////////////////////////////////////////////////////////////////////////////////////////////////
extern "C" void NsRegisterReflection_NoesisApp()
{
PACKAGE_REGISTER(Render, RenderContext);
PACKAGE_REGISTER(Render, GLRenderDevice);
PACKAGE_REGISTER(App, Display);
PACKAGE_REGISTER(Render, GLRenderContext);
PACKAGE_REGISTER(App, Providers);
PACKAGE_REGISTER(App, Launcher);
PACKAGE_REGISTER(App, Theme);
PACKAGE_REGISTER(App, DisplayLauncher);
PACKAGE_REGISTER(App, ApplicationLauncher);
PACKAGE_REGISTER(App, Interactivity);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
extern "C" void NsInitPackages_NoesisApp()
{
PACKAGE_INIT(Render, RenderContext);
PACKAGE_INIT(Render, GLRenderDevice);
PACKAGE_INIT(App, Display);
PACKAGE_INIT(Render, GLRenderContext);
PACKAGE_INIT(App, Providers);
PACKAGE_INIT(App, Launcher);
PACKAGE_INIT(App, Theme);
PACKAGE_INIT(App, DisplayLauncher);
PACKAGE_INIT(App, ApplicationLauncher);
PACKAGE_INIT(App, Interactivity);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
extern "C" void NsShutdownPackages_NoesisApp()
{
PACKAGE_SHUTDOWN(App, Interactivity);
PACKAGE_SHUTDOWN(App, ApplicationLauncher);
PACKAGE_SHUTDOWN(App, DisplayLauncher);
PACKAGE_SHUTDOWN(App, Theme);
PACKAGE_SHUTDOWN(App, Launcher);
PACKAGE_SHUTDOWN(App, Providers);
PACKAGE_SHUTDOWN(Render, GLRenderContext);
PACKAGE_SHUTDOWN(App, Display);
PACKAGE_SHUTDOWN(Render, GLRenderDevice);
PACKAGE_SHUTDOWN(Render, RenderContext);
}
================================================
FILE: 3rdparty/exprtk/CMakeLists.txt
================================================
add_library(exprtk)
target_include_directories(exprtk
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}
)
target_sources(exprtk
PRIVATE
exprtk.hpp
exprtk.cpp
)
================================================
FILE: 3rdparty/exprtk/exprtk.cpp
================================================
#include "exprtk.hpp"
================================================
FILE: 3rdparty/exprtk/exprtk.hpp
================================================
/*
******************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Author: Arash Partow (1999-2017) *
* URL: http://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
* Free use of the C++ Mathematical Expression Toolkit Library is *
* permitted under the guidelines and in accordance with the most *
* current version of the MIT License. *
* http://www.opensource.org/licenses/MIT *
* *
* Example expressions: *
* (00) (y + x / y) * (x - y / x) *
* (01) (x^2 / sin(2 * pi / y)) - x / 2 *
* (02) sqrt(1 - (x^2)) *
* (03) 1 - sin(2 * x) + cos(pi / y) *
* (04) a * exp(2 * t) + c *
* (05) if(((x + 2) == 3) and ((y + 5) <= 9),1 + w, 2 / z) *
* (06) (avg(x,y) <= x + y ? x - y : x * y) + 2 * pi / x *
* (07) z := x + sin(2 * pi / y) *
* (08) u := 2 * (pi * z) / (w := x + cos(y / pi)) *
* (09) clamp(-1,sin(2 * pi * x) + cos(y / 2 * pi),+1) *
* (10) inrange(-2,m,+2) == if(({-2 <= m} and [m <= +2]),1,0) *
* (11) (2sin(x)cos(2y)7 + 1) == (2 * sin(x) * cos(2*y) * 7 + 1) *
* (12) (x ilike 's*ri?g') and [y < (3 z^7 + w)] *
* *
******************************************************************
*/
#ifndef INCLUDE_EXPRTK_HPP
#define INCLUDE_EXPRTK_HPP
#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <exception>
#include <functional>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
namespace exprtk
{
#ifdef exprtk_enable_debugging
#define exprtk_debug(params) printf params
#else
#define exprtk_debug(params) (void)0
#endif
#define exprtk_error_location \
"exprtk.hpp:" + details::to_str(__LINE__) \
#if __GNUC__ >= 7
#define exprtk_disable_fallthrough_begin \
_Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wimplicit-fallthrough\"") \
#define exprtk_disable_fallthrough_end \
_Pragma ("GCC diagnostic pop") \
#else
#define exprtk_disable_fallthrough_begin (void)0;
#define exprtk_disable_fallthrough_end (void)0;
#endif
namespace details
{
typedef unsigned char uchar_t;
typedef char char_t;
inline bool is_whitespace(const char_t c)
{
return (' ' == c) || ('\n' == c) ||
('\r' == c) || ('\t' == c) ||
('\b' == c) || ('\v' == c) ||
('\f' == c) ;
}
inline bool is_operator_char(const char_t c)
{
return ('+' == c) || ('-' == c) ||
('*' == c) || ('/' == c) ||
('^' == c) || ('<' == c) ||
('>' == c) || ('=' == c) ||
(',' == c) || ('!' == c) ||
('(' == c) || (')' == c) ||
('[' == c) || (']' == c) ||
('{' == c) || ('}' == c) ||
('%' == c) || (':' == c) ||
('?' == c) || ('&' == c) ||
('|' == c) || (';' == c) ;
}
inline bool is_letter(const char_t c)
{
return (('a' <= c) && (c <= 'z')) ||
(('A' <= c) && (c <= 'Z')) ;
}
inline bool is_digit(const char_t c)
{
return ('0' <= c) && (c <= '9');
}
inline bool is_letter_or_digit(const char_t c)
{
return is_letter(c) || is_digit(c);
}
inline bool is_left_bracket(const char_t c)
{
return ('(' == c) || ('[' == c) || ('{' == c);
}
inline bool is_right_bracket(const char_t c)
{
return (')' == c) || (']' == c) || ('}' == c);
}
inline bool is_bracket(const char_t c)
{
return is_left_bracket(c) || is_right_bracket(c);
}
inline bool is_sign(const char_t c)
{
return ('+' == c) || ('-' == c);
}
inline bool is_invalid(const char_t c)
{
return !is_whitespace (c) &&
!is_operator_char(c) &&
!is_letter (c) &&
!is_digit (c) &&
('.' != c) &&
('_' != c) &&
('$' != c) &&
('~' != c) &&
('\'' != c);
}
#ifndef exprtk_disable_caseinsensitivity
inline void case_normalise(std::string& s)
{
for (std::size_t i = 0; i < s.size(); ++i)
{
s[i] = static_cast<std::string::value_type>(std::tolower(s[i]));
}
}
inline bool imatch(const char_t c1, const char_t c2)
{
return std::tolower(c1) == std::tolower(c2);
}
inline bool imatch(const std::string& s1, const std::string& s2)
{
if (s1.size() == s2.size())
{
for (std::size_t i = 0; i < s1.size(); ++i)
{
if (std::tolower(s1[i]) != std::tolower(s2[i]))
{
return false;
}
}
return true;
}
return false;
}
struct ilesscompare
{
inline bool operator() (const std::string& s1, const std::string& s2) const
{
const std::size_t length = std::min(s1.size(),s2.size());
for (std::size_t i = 0; i < length; ++i)
{
const char_t c1 = static_cast<char>(std::tolower(s1[i]));
const char_t c2 = static_cast<char>(std::tolower(s2[i]));
if (c1 > c2)
return false;
else if (c1 < c2)
return true;
}
return s1.size() < s2.size();
}
};
#else
inline void case_normalise(std::string&)
{}
inline bool imatch(const char_t c1, const char_t c2)
{
return c1 == c2;
}
inline bool imatch(const std::string& s1, const std::string& s2)
{
return s1 == s2;
}
struct ilesscompare
{
inline bool operator() (const std::string& s1, const std::string& s2) const
{
return s1 < s2;
}
};
#endif
inline bool is_valid_sf_symbol(const std::string& symbol)
{
// Special function: $f12 or $F34
return (4 == symbol.size()) &&
('$' == symbol[0]) &&
imatch('f',symbol[1]) &&
is_digit(symbol[2]) &&
is_digit(symbol[3]);
}
inline const char_t& front(const std::string& s)
{
return s[0];
}
inline const char_t& back(const std::string& s)
{
return s[s.size() - 1];
}
inline std::string to_str(int i)
{
if (0 == i)
return std::string("0");
std::string result;
if (i < 0)
{
for ( ; i; i /= 10)
{
result += '0' + char(-(i % 10));
}
result += '-';
}
else
{
for ( ; i; i /= 10)
{
result += '0' + char(i % 10);
}
}
std::reverse(result.begin(), result.end());
return result;
}
inline std::string to_str(std::size_t i)
{
return to_str(static_cast<int>(i));
}
inline bool is_hex_digit(const std::string::value_type digit)
{
return (('0' <= digit) && (digit <= '9')) ||
(('A' <= digit) && (digit <= 'F')) ||
(('a' <= digit) && (digit <= 'f')) ;
}
inline uchar_t hex_to_bin(uchar_t h)
{
if (('0' <= h) && (h <= '9'))
return (h - '0');
else
return static_cast<unsigned char>(std::toupper(h) - 'A');
}
template <typename Iterator>
inline void parse_hex(Iterator& itr, Iterator end, std::string::value_type& result)
{
if (
(end != (itr )) &&
(end != (itr + 1)) &&
(end != (itr + 2)) &&
(end != (itr + 3)) &&
('0' == *(itr )) &&
(
('x' == *(itr + 1)) ||
('X' == *(itr + 1))
) &&
(is_hex_digit(*(itr + 2))) &&
(is_hex_digit(*(itr + 3)))
)
{
result = hex_to_bin(static_cast<uchar_t>(*(itr + 2))) << 4 |
hex_to_bin(static_cast<uchar_t>(*(itr + 3))) ;
itr += 3;
}
else
result = '\0';
}
inline void cleanup_escapes(std::string& s)
{
typedef std::string::iterator str_itr_t;
str_itr_t itr1 = s.begin();
str_itr_t itr2 = s.begin();
str_itr_t end = s.end ();
std::size_t removal_count = 0;
while (end != itr1)
{
if ('\\' == (*itr1))
{
++removal_count;
if (end == ++itr1)
break;
else if ('\\' != (*itr1))
{
switch (*itr1)
{
case 'n' : (*itr1) = '\n'; break;
case 'r' : (*itr1) = '\r'; break;
case 't' : (*itr1) = '\t'; break;
case '0' : parse_hex(itr1, end, (*itr1));
removal_count += 3;
break;
}
continue;
}
}
if (itr1 != itr2)
{
(*itr2) = (*itr1);
}
++itr1;
++itr2;
}
s.resize(s.size() - removal_count);
}
class build_string
{
public:
build_string(const std::size_t& initial_size = 64)
{
data_.reserve(initial_size);
}
inline build_string& operator << (const std::string& s)
{
data_ += s;
return (*this);
}
inline build_string& operator << (const char_t* s)
{
data_ += std::string(s);
return (*this);
}
inline operator std::string () const
{
return data_;
}
inline std::string as_string() const
{
return data_;
}
private:
std::string data_;
};
static const std::string reserved_words[] =
{
"break", "case", "continue", "default", "false", "for",
"if", "else", "ilike", "in", "like", "and", "nand", "nor",
"not", "null", "or", "repeat", "return", "shl", "shr",
"swap", "switch", "true", "until", "var", "while", "xnor",
"xor", "&", "|"
};
static const std::size_t reserved_words_size = sizeof(reserved_words) / sizeof(std::string);
static const std::string reserved_symbols[] =
{
"abs", "acos", "acosh", "and", "asin", "asinh", "atan",
"atanh", "atan2", "avg", "break", "case", "ceil", "clamp",
"continue", "cos", "cosh", "cot", "csc", "default",
"deg2grad", "deg2rad", "equal", "erf", "erfc", "exp",
"expm1", "false", "floor", "for", "frac", "grad2deg",
"hypot", "iclamp", "if", "else", "ilike", "in", "inrange",
"like", "log", "log10", "log2", "logn", "log1p", "mand",
"max", "min", "mod", "mor", "mul", "ncdf", "nand", "nor",
"not", "not_equal", "null", "or", "pow", "rad2deg",
"repeat", "return", "root", "round", "roundn", "sec", "sgn",
"shl", "shr", "sin", "sinc", "sinh", "sqrt", "sum", "swap",
"switch", "tan", "tanh", "true", "trunc", "until", "var",
"while", "xnor", "xor", "&", "|"
};
static const std::size_t reserved_symbols_size = sizeof(reserved_symbols) / sizeof(std::string);
static const std::string base_function_list[] =
{
"abs", "acos", "acosh", "asin", "asinh", "atan", "atanh",
"atan2", "avg", "ceil", "clamp", "cos", "cosh", "cot",
"csc", "equal", "erf", "erfc", "exp", "expm1", "floor",
"frac", "hypot", "iclamp", "like", "log", "log10", "log2",
"logn", "log1p", "mand", "max", "min", "mod", "mor", "mul",
"ncdf", "pow", "root", "round", "roundn", "sec", "sgn",
"sin", "sinc", "sinh", "sqrt", "sum", "swap", "tan", "tanh",
"trunc", "not_equal", "inrange", "deg2grad", "deg2rad",
"rad2deg", "grad2deg"
};
static const std::size_t base_function_list_size = sizeof(base_function_list) / sizeof(std::string);
static const std::string logic_ops_list[] =
{
"and", "nand", "nor", "not", "or", "xnor", "xor", "&", "|"
};
static const std::size_t logic_ops_list_size = sizeof(logic_ops_list) / sizeof(std::string);
static const std::string cntrl_struct_list[] =
{
"if", "switch", "for", "while", "repeat", "return"
};
static const std::size_t cntrl_struct_list_size = sizeof(cntrl_struct_list) / sizeof(std::string);
static const std::string arithmetic_ops_list[] =
{
"+", "-", "*", "/", "%", "^"
};
static const std::size_t arithmetic_ops_list_size = sizeof(arithmetic_ops_list) / sizeof(std::string);
static const std::string assignment_ops_list[] =
{
":=", "+=", "-=",
"*=", "/=", "%="
};
static const std::size_t assignment_ops_list_size = sizeof(assignment_ops_list) / sizeof(std::string);
static const std::string inequality_ops_list[] =
{
"<", "<=", "==",
"=", "!=", "<>",
">=", ">"
};
static const std::size_t inequality_ops_list_size = sizeof(inequality_ops_list) / sizeof(std::string);
inline bool is_reserved_word(const std::string& symbol)
{
for (std::size_t i = 0; i < reserved_words_size; ++i)
{
if (imatch(symbol, reserved_words[i]))
{
return true;
}
}
return false;
}
inline bool is_reserved_symbol(const std::string& symbol)
{
for (std::size_t i = 0; i < reserved_symbols_size; ++i)
{
if (imatch(symbol, reserved_symbols[i]))
{
return true;
}
}
return false;
}
inline bool is_base_function(const std::string& function_name)
{
for (std::size_t i = 0; i < base_function_list_size; ++i)
{
if (imatch(function_name, base_function_list[i]))
{
return true;
}
}
return false;
}
inline bool is_control_struct(const std::string& cntrl_strct)
{
for (std::size_t i = 0; i < cntrl_struct_list_size; ++i)
{
if (imatch(cntrl_strct, cntrl_struct_list[i]))
{
return true;
}
}
return false;
}
inline bool is_logic_opr(const std::string& lgc_opr)
{
for (std::size_t i = 0; i < logic_ops_list_size; ++i)
{
if (imatch(lgc_opr, logic_ops_list[i]))
{
return true;
}
}
return false;
}
struct cs_match
{
static inline bool cmp(const char_t c0, const char_t c1)
{
return (c0 == c1);
}
};
struct cis_match
{
static inline bool cmp(const char_t c0, const char_t c1)
{
return (std::tolower(c0) == std::tolower(c1));
}
};
template <typename Iterator, typename Compare>
inline bool match_impl(const Iterator pattern_begin,
const Iterator pattern_end,
const Iterator data_begin,
const Iterator data_end,
const typename std::iterator_traits<Iterator>::value_type& zero_or_more,
const typename std::iterator_traits<Iterator>::value_type& zero_or_one)
{
if (0 == std::distance(data_begin,data_end))
{
return false;
}
Iterator d_itr = data_begin;
Iterator p_itr = pattern_begin;
Iterator c_itr = data_begin;
Iterator m_itr = data_begin;
while ((data_end != d_itr) && (zero_or_more != (*p_itr)))
{
if ((!Compare::cmp((*p_itr),(*d_itr))) && (zero_or_one != (*p_itr)))
{
return false;
}
++p_itr;
++d_itr;
}
while (data_end != d_itr)
{
if (zero_or_more == (*p_itr))
{
if (pattern_end == (++p_itr))
{
return true;
}
m_itr = p_itr;
c_itr = d_itr;
++c_itr;
}
else if ((Compare::cmp((*p_itr),(*d_itr))) || (zero_or_one == (*p_itr)))
{
++p_itr;
++d_itr;
}
else
{
p_itr = m_itr;
d_itr = c_itr++;
}
}
while ((p_itr != pattern_end) && (zero_or_more == (*p_itr))) { ++p_itr; }
return (p_itr == pattern_end);
}
inline bool wc_match(const std::string& wild_card,
const std::string& str)
{
return match_impl<const char_t*,cs_match>(wild_card.data(),
wild_card.data() + wild_card.size(),
str.data(),
str.data() + str.size(),
'*',
'?');
}
inline bool wc_imatch(const std::string& wild_card,
const std::string& str)
{
return match_impl<const char_t*,cis_match>(wild_card.data(),
wild_card.data() + wild_card.size(),
str.data(),
str.data() + str.size(),
'*',
'?');
}
inline bool sequence_match(const std::string& pattern,
const std::string& str,
std::size_t& diff_index,
char_t& diff_value)
{
if (str.empty())
{
return ("Z" == pattern);
}
else if ('*' == pattern[0])
return false;
typedef std::string::const_iterator itr_t;
itr_t p_itr = pattern.begin();
itr_t s_itr = str .begin();
itr_t p_end = pattern.end();
itr_t s_end = str .end();
while ((s_end != s_itr) && (p_end != p_itr))
{
if ('*' == (*p_itr))
{
const char_t target = static_cast<char>(std::toupper(*(p_itr - 1)));
if ('*' == target)
{
diff_index = static_cast<std::size_t>(std::distance(str.begin(),s_itr));
diff_value = static_cast<char>(std::toupper(*p_itr));
return false;
}
else
++p_itr;
while (s_itr != s_end)
{
if (target != std::toupper(*s_itr))
break;
else
++s_itr;
}
continue;
}
else if (
('?' != *p_itr) &&
std::toupper(*p_itr) != std::toupper(*s_itr)
)
{
diff_index = static_cast<std::size_t>(std::distance(str.begin(),s_itr));
diff_value = static_cast<char>(std::toupper(*p_itr));
return false;
}
++p_itr;
++s_itr;
}
return (
(s_end == s_itr) &&
(
(p_end == p_itr) ||
('*' == *p_itr)
)
);
}
static const double pow10[] = {
1.0,
1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004,
1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008,
1.0E+009, 1.0E+010, 1.0E+011, 1.0E+012,
1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016
};
static const std::size_t pow10_size = sizeof(pow10) / sizeof(double);
namespace numeric
{
namespace constant
{
static const double e = 2.71828182845904523536028747135266249775724709369996;
static const double pi = 3.14159265358979323846264338327950288419716939937510;
static const double pi_2 = 1.57079632679489661923132169163975144209858469968755;
static const double pi_4 = 0.78539816339744830961566084581987572104929234984378;
static const double pi_180 = 0.01745329251994329576923690768488612713442871888542;
static const double _1_pi = 0.31830988618379067153776752674502872406891929148091;
static const double _2_pi = 0.63661977236758134307553505349005744813783858296183;
static const double _180_pi = 57.29577951308232087679815481410517033240547246656443;
static const double log2 = 0.69314718055994530941723212145817656807550013436026;
static const double sqrt2 = 1.41421356237309504880168872420969807856967187537695;
}
namespace details
{
struct unknown_type_tag { unknown_type_tag() {} };
struct real_type_tag { real_type_tag () {} };
struct complex_type_tag { complex_type_tag() {} };
struct int_type_tag { int_type_tag () {} };
template <typename T>
struct number_type
{
typedef unknown_type_tag type;
number_type() {}
};
#define exprtk_register_real_type_tag(T) \
template<> struct number_type<T> \
{ typedef real_type_tag type; number_type() {} }; \
#define exprtk_register_complex_type_tag(T) \
template<> struct number_type<std::complex<T> > \
{ typedef complex_type_tag type; number_type() {} }; \
#define exprtk_register_int_type_tag(T) \
template<> struct number_type<T> \
{ typedef int_type_tag type; number_type() {} }; \
exprtk_register_real_type_tag(double )
exprtk_register_real_type_tag(long double)
exprtk_register_real_type_tag(float )
exprtk_register_complex_type_tag(double )
exprtk_register_complex_type_tag(long double)
exprtk_register_complex_type_tag(float )
exprtk_register_int_type_tag(short )
exprtk_register_int_type_tag(int )
exprtk_register_int_type_tag(long long int )
exprtk_register_int_type_tag(unsigned short )
exprtk_register_int_type_tag(unsigned int )
exprtk_register_int_type_tag(unsigned long long int)
#undef exprtk_register_real_type_tag
#undef exprtk_register_int_type_tag
template <typename T>
struct epsilon_type
{
static inline T value()
{
const T epsilon = T(0.0000000001);
return epsilon;
}
};
template <>
struct epsilon_type <float>
{
static inline float value()
{
const float epsilon = float(0.000001f);
return epsilon;
}
};
template <>
struct epsilon_type <long double>
{
static inline long double value()
{
const long double epsilon = (long double)(0.000000000001);
return epsilon;
}
};
template <typename T>
inline bool is_nan_impl(const T v, real_type_tag)
{
return std::not_equal_to<T>()(v,v);
}
template <typename T>
inline int to_int32_impl(const T v, real_type_tag)
{
return static_cast<int>(v);
}
template <typename T>
inline long long int to_int64_impl(const T v, real_type_tag)
{
return static_cast<long long int>(v);
}
template <typename T>
inline bool is_true_impl(const T v)
{
return std::not_equal_to<T>()(T(0),v);
}
template <typename T>
inline bool is_false_impl(const T v)
{
return std::equal_to<T>()(T(0),v);
}
template <typename T>
inline T abs_impl(const T v, real_type_tag)
{
return ((v < T(0)) ? -v : v);
}
template <typename T>
inline T min_impl(const T v0, const T v1, real_type_tag)
{
return std::min<T>(v0,v1);
}
template <typename T>
inline T max_impl(const T v0, const T v1, real_type_tag)
{
return std::max<T>(v0,v1);
}
template <typename T>
inline T equal_impl(const T v0, const T v1, real_type_tag)
{
const T epsilon = epsilon_type<T>::value();
return (abs_impl(v0 - v1,real_type_tag()) <= (std::max(T(1),std::max(abs_impl(v0,real_type_tag()),abs_impl(v1,real_type_tag()))) * epsilon)) ? T(1) : T(0);
}
inline float equal_impl(const float v0, const float v1, real_type_tag)
{
const float epsilon = epsilon_type<float>::value();
return (abs_impl(v0 - v1,real_type_tag()) <= (std::max(1.0f,std::max(abs_impl(v0,real_type_tag()),abs_impl(v1,real_type_tag()))) * epsilon)) ? 1.0f : 0.0f;
}
template <typename T>
inline T equal_impl(const T v0, const T v1, int_type_tag)
{
return (v0 == v1) ? 1 : 0;
}
template <typename T>
inline T expm1_impl(const T v, real_type_tag)
{
// return std::expm1<T>(v);
if (abs_impl(v,real_type_tag()) < T(0.00001))
return v + (T(0.5) * v * v);
else
return std::exp(v) - T(1);
}
template <typename T>
inline T expm1_impl(const T v, int_type_tag)
{
return T(std::exp<double>(v)) - T(1);
}
template <typename T>
inline T nequal_impl(const T v0, const T v1, real_type_tag)
{
typedef real_type_tag rtg;
const T epsilon = epsilon_type<T>::value();
return (abs_impl(v0 - v1,rtg()) > (std::max(T(1),std::max(abs_impl(v0,rtg()),abs_impl(v1,rtg()))) * epsilon)) ? T(1) : T(0);
}
inline float nequal_impl(const float v0, const float v1, real_type_tag)
{
typedef real_type_tag rtg;
const float epsilon = epsilon_type<float>::value();
return (abs_impl(v0 - v1,rtg()) > (std::max(1.0f,std::max(abs_impl(v0,rtg()),abs_impl(v1,rtg()))) * epsilon)) ? 1.0f : 0.0f;
}
template <typename T>
inline T nequal_impl(const T v0, const T v1, int_type_tag)
{
return (v0 != v1) ? 1 : 0;
}
template <typename T>
inline T modulus_impl(const T v0, const T v1, real_type_tag)
{
return std::fmod(v0,v1);
}
template <typename T>
inline T modulus_impl(const T v0, const T v1, int_type_tag)
{
return v0 % v1;
}
template <typename T>
inline T pow_impl(const T v0, const T v1, real_type_tag)
{
return std::pow(v0,v1);
}
template <typename T>
inline T pow_impl(const T v0, const T v1, int_type_tag)
{
return std::pow(static_cast<double>(v0),static_cast<double>(v1));
}
template <typename T>
inline T logn_impl(const T v0, const T v1, real_type_tag)
{
return std::log(v0) / std::log(v1);
}
template <typename T>
inline T logn_impl(const T v0, const T v1, int_type_tag)
{
return static_cast<T>(logn_impl<double>(static_cast<double>(v0),static_cast<double>(v1),real_type_tag()));
}
template <typename T>
inline T log1p_impl(const T v, real_type_tag)
{
if (v > T(-1))
{
if (abs_impl(v,real_type_tag()) > T(0.0001))
{
return std::log(T(1) + v);
}
else
return (T(-0.5) * v + T(1)) * v;
}
else
return std::numeric_limits<T>::quiet_NaN();
}
template <typename T>
inline T log1p_impl(const T v, int_type_tag)
{
if (v > T(-1))
{
return std::log(T(1) + v);
}
else
return std::numeric_limits<T>::quiet_NaN();
}
template <typename T>
inline T root_impl(const T v0, const T v1, real_type_tag)
{
if (v1 < T(0))
return std::numeric_limits<T>::quiet_NaN();
const std::size_t n = static_cast<std::size_t>(v1);
if ((v0 < T(0)) && (0 == (n % 2)))
return std::numeric_limits<T>::quiet_NaN();
return std::pow(v0, T(1) / n);
}
template <typename T>
inline T root_impl(const T v0, const T v1, int_type_tag)
{
return root_impl<double>(static_cast<double>(v0),static_cast<double>(v1),real_type_tag());
}
template <typename T>
inline T round_impl(const T v, real_type_tag)
{
return ((v < T(0)) ? std::ceil(v - T(0.5)) : std::floor(v + T(0.5)));
}
template <typename T>
inline T roundn_impl(const T v0, const T v1, real_type_tag)
{
const int index = std::max<int>(0, std::min<int>(pow10_size - 1, (int)std::floor(v1)));
const T p10 = T(pow10[index]);
if (v0 < T(0))
return T(std::ceil ((v0 * p10) - T(0.5)) / p10);
else
return T(std::floor((v0 * p10) + T(0.5)) / p10);
}
template <typename T>
inline T roundn_impl(const T v0, const T, int_type_tag)
{
return v0;
}
template <typename T>
inline T hypot_impl(const T v0, const T v1, real_type_tag)
{
return std::sqrt((v0 * v0) + (v1 * v1));
}
template <typename T>
inline T hypot_impl(const T v0, const T v1, int_type_tag)
{
return static_cast<T>(std::sqrt(static_cast<double>((v0 * v0) + (v1 * v1))));
}
template <typename T>
inline T atan2_impl(const T v0, const T v1, real_type_tag)
{
return std::atan2(v0,v1);
}
template <typename T>
inline T atan2_impl(const T, const T, int_type_tag)
{
return 0;
}
template <typename T>
inline T shr_impl(const T v0, const T v1, real_type_tag)
{
return v0 * (T(1) / std::pow(T(2),static_cast<T>(static_cast<int>(v1))));
}
template <typename T>
inline T shr_impl(const T v0, const T v1, int_type_tag)
{
return v0 >> v1;
}
template <typename T>
inline T shl_impl(const T v0, const T v1, real_type_tag)
{
return v0 * std::pow(T(2),static_cast<T>(static_cast<int>(v1)));
}
template <typename T>
inline T shl_impl(const T v0, const T v1, int_type_tag)
{
return v0 << v1;
}
template <typename T>
inline T sgn_impl(const T v, real_type_tag)
{
if (v > T(0)) return T(+1);
else if (v < T(0)) return T(-1);
else return T( 0);
}
template <typename T>
inline T sgn_impl(const T v, int_type_tag)
{
if (v > T(0)) return T(+1);
else if (v < T(0)) return T(-1);
else return T( 0);
}
template <typename T>
inline T and_impl(const T v0, const T v1, real_type_tag)
{
return (is_true_impl(v0) && is_true_impl(v1)) ? T(1) : T(0);
}
template <typename T>
inline T and_impl(const T v0, const T v1, int_type_tag)
{
return v0 && v1;
}
template <typename T>
inline T nand_impl(const T v0, const T v1, real_type_tag)
{
return (is_false_impl(v0) || is_false_impl(v1)) ? T(1) : T(0);
}
template <typename T>
inline T nand_impl(const T v0, const T v1, int_type_tag)
{
return !(v0 && v1);
}
template <typename T>
inline T or_impl(const T v0, const T v1, real_type_tag)
{
return (is_true_impl(v0) || is_true_impl(v1)) ? T(1) : T(0);
}
template <typename T>
inline T or_impl(const T v0, const T v1, int_type_tag)
{
return (v0 || v1);
}
template <typename T>
inline T nor_impl(const T v0, const T v1, real_type_tag)
{
return (is_false_impl(v0) && is_false_impl(v1)) ? T(1) : T(0);
}
template <typename T>
inline T nor_impl(const T v0, const T v1, int_type_tag)
{
return !(v0 || v1);
}
template <typename T>
inline T xor_impl(const T v0, const T v1, real_type_tag)
{
return (is_false_impl(v0) != is_false_impl(v1)) ? T(1) : T(0);
}
template <typename T>
inline T xor_impl(const T v0, const T v1, int_type_tag)
{
return v0 ^ v1;
}
template <typename T>
inline T xnor_impl(const T v0, const T v1, real_type_tag)
{
const bool v0_true = is_true_impl(v0);
const bool v1_true = is_true_impl(v1);
if ((v0_true && v1_true) || (!v0_true && !v1_true))
return T(1);
else
return T(0);
}
template <typename T>
inline T xnor_impl(const T v0, const T v1, int_type_tag)
{
const bool v0_true = is_true_impl(v0);
const bool v1_true = is_true_impl(v1);
if ((v0_true && v1_true) || (!v0_true && !v1_true))
return T(1);
else
return T(0);
}
#if (defined(_MSC_VER) && (_MSC_VER >= 1900)) || !defined(_MSC_VER)
#define exprtk_define_erf(TT,impl) \
inline TT erf_impl(TT v) { return impl(v); } \
exprtk_define_erf( float,::erff)
exprtk_define_erf( double,::erf )
exprtk_define_erf(long double,::erfl)
#undef exprtk_define_erf
#endif
template <typename T>
inline T erf_impl(T v, real_type_tag)
{
#if defined(_MSC_VER) && (_MSC_VER < 1900)
// Credits: Abramowitz & Stegun Equations 7.1.25-28
static const T c[] = {
T( 1.26551223), T(1.00002368),
T( 0.37409196), T(0.09678418),
T(-0.18628806), T(0.27886807),
T(-1.13520398), T(1.48851587),
T(-0.82215223), T(0.17087277)
};
const T t = T(1) / (T(1) + T(0.5) * abs_impl(v,real_type_tag()));
T result = T(1) - t * std::exp((-v * v) -
c[0] + t * (c[1] + t *
(c[2] + t * (c[3] + t *
(c[4] + t * (c[5] + t *
(c[6] + t * (c[7] + t *
(c[8] + t * (c[9]))))))))));
return (v >= T(0)) ? result : -result;
#else
return erf_impl(v);
#endif
}
template <typename T>
inline T erf_impl(T v, int_type_tag)
{
return erf_impl(static_cast<double>(v),real_type_tag());
}
#if (defined(_MSC_VER) && (_MSC_VER >= 1900)) || !defined(_MSC_VER)
#define exprtk_define_erfc(TT,impl) \
inline TT erfc_impl(TT v) { return impl(v); } \
exprtk_define_erfc( float,::erfcf)
exprtk_define_erfc( double,::erfc )
exprtk_define_erfc(long double,::erfcl)
#undef exprtk_define_erfc
#endif
template <typename T>
inline T erfc_impl(T v, real_type_tag)
{
#if defined(_MSC_VER) && (_MSC_VER < 1900)
return T(1) - erf_impl(v,real_type_tag());
#else
return erfc_impl(v);
#endif
}
template <typename T>
inline T erfc_impl(T v, int_type_tag)
{
return erfc_impl(static_cast<double>(v),real_type_tag());
}
template <typename T>
inline T ncdf_impl(T v, real_type_tag)
{
T cnd = T(0.5) * (T(1) + erf_impl(
abs_impl(v,real_type_tag()) /
T(numeric::constant::sqrt2),real_type_tag()));
return (v < T(0)) ? (T(1) - cnd) : cnd;
}
template <typename T>
inline T ncdf_impl(T v, int_type_tag)
{
return ncdf_impl(static_cast<double>(v),real_type_tag());
}
template <typename T>
inline T sinc_impl(T v, real_type_tag)
{
if (std::abs(v) >= std::numeric_limits<T>::epsilon())
return(std::sin(v) / v);
else
return T(1);
}
template <typename T>
inline T sinc_impl(T v, int_type_tag)
{
return sinc_impl(static_cast<double>(v),real_type_tag());
}
template <typename T> inline T acos_impl(const T v, real_type_tag) { return std::acos (v); }
template <typename T> inline T acosh_impl(const T v, real_type_tag) { return std::log(v + std::sqrt((v * v) - T(1))); }
template <typename T> inline T asin_impl(const T v, real_type_tag) { return std::asin (v); }
template <typename T> inline T asinh_impl(const T v, real_type_tag) { return std::log(v + std::sqrt((v * v) + T(1))); }
template <typename T> inline T atan_impl(const T v, real_type_tag) { return std::atan (v); }
template <typename T> inline T atanh_impl(const T v, real_type_tag) { return (std::log(T(1) + v) - std::log(T(1) - v)) / T(2); }
template <typename T> inline T ceil_impl(const T v, real_type_tag) { return std::ceil (v); }
template <typename T> inline T cos_impl(const T v, real_type_tag) { return std::cos (v); }
template <typename T> inline T cosh_impl(const T v, real_type_tag) { return std::cosh (v); }
template <typename T> inline T exp_impl(const T v, real_type_tag) { return std::exp (v); }
template <typename T> inline T floor_impl(const T v, real_type_tag) { return std::floor(v); }
template <typename T> inline T log_impl(const T v, real_type_tag) { return std::log (v); }
template <typename T> inline T log10_impl(const T v, real_type_tag) { return std::log10(v); }
template <typename T> inline T log2_impl(const T v, real_type_tag) { return std::log(v)/T(numeric::constant::log2); }
template <typename T> inline T neg_impl(const T v, real_type_tag) { return -v; }
template <typename T> inline T pos_impl(const T v, real_type_tag) { return +v; }
template <typename T> inline T sin_impl(const T v, real_type_tag) { return std::sin (v); }
template <typename T> inline T sinh_impl(const T v, real_type_tag) { return std::sinh (v); }
template <typename T> inline T sqrt_impl(const T v, real_type_tag) { return std::sqrt (v); }
template <typename T> inline T tan_impl(const T v, real_type_tag) { return std::tan (v); }
template <typename T> inline T tanh_impl(const T v, real_type_tag) { return std::tanh (v); }
template <typename T> inline T cot_impl(const T v, real_type_tag) { return T(1) / std::tan(v); }
template <typename T> inline T sec_impl(const T v, real_type_tag) { return T(1) / std::cos(v); }
template <typename T> inline T csc_impl(const T v, real_type_tag) { return T(1) / std::sin(v); }
template <typename T> inline T r2d_impl(const T v, real_type_tag) { return (v * T(numeric::constant::_180_pi)); }
template <typename T> inline T d2r_impl(const T v, real_type_tag) { return (v * T(numeric::constant::pi_180)); }
template <typename T> inline T d2g_impl(const T v, real_type_tag) { return (v * T(20.0/9.0)); }
template <typename T> inline T g2d_impl(const T v, real_type_tag) { return (v * T(9.0/20.0)); }
template <typename T> inline T notl_impl(const T v, real_type_tag) { return (std::not_equal_to<T>()(T(0),v) ? T(0) : T(1)); }
template <typename T> inline T frac_impl(const T v, real_type_tag) { return (v - static_cast<long long>(v)); }
template <typename T> inline T trunc_impl(const T v, real_type_tag) { return T(static_cast<long long>(v)); }
template <typename T> inline T const_pi_impl(real_type_tag) { return numeric::constant::pi; }
template <typename T> inline T const_e_impl (real_type_tag) { return numeric::constant::e; }
template <typename T> inline T abs_impl(const T v, int_type_tag) { return ((v >= T(0)) ? v : -v); }
template <typename T> inline T exp_impl(const T v, int_type_tag) { return std::exp (v); }
template <typename T> inline T log_impl(const T v, int_type_tag) { return std::log (v); }
template <typename T> inline T log10_impl(const T v, int_type_tag) { return std::log10(v); }
template <typename T> inline T log2_impl(const T v, int_type_tag) { return std::log(v)/T(numeric::constant::log2); }
template <typename T> inline T neg_impl(const T v, int_type_tag) { return -v; }
template <typename T> inline T pos_impl(const T v, int_type_tag) { return +v; }
template <typename T> inline T ceil_impl(const T v, int_type_tag) { return v; }
template <typename T> inline T floor_impl(const T v, int_type_tag) { return v; }
template <typename T> inline T round_impl(const T v, int_type_tag) { return v; }
template <typename T> inline T notl_impl(const T v, int_type_tag) { return !v; }
template <typename T> inline T sqrt_impl(const T v, int_type_tag) { return std::sqrt (v); }
template <typename T> inline T frac_impl(const T , int_type_tag) { return T(0); }
template <typename T> inline T trunc_impl(const T v, int_type_tag) { return v; }
template <typename T> inline T acos_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T acosh_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T asin_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T asinh_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T atan_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T atanh_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T cos_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T cosh_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T sin_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T sinh_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T tan_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T tanh_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T cot_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T sec_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T> inline T csc_impl(const T , int_type_tag) { return std::numeric_limits<T>::quiet_NaN(); }
template <typename T>
inline bool is_integer_impl(const T& v, real_type_tag)
{
return std::equal_to<T>()(T(0),std::fmod(v,T(1)));
}
template <typename T>
inline bool is_integer_impl(const T&, int_type_tag)
{
return true;
}
}
template <typename Type>
struct numeric_info { enum { length = 0, size = 32, bound_length = 0, min_exp = 0, max_exp = 0 }; };
template<> struct numeric_info<int> { enum { length = 10, size = 16, bound_length = 9}; };
template<> struct numeric_info<float> { enum { min_exp = -38, max_exp = +38}; };
template<> struct numeric_info<double> { enum { min_exp = -308, max_exp = +308}; };
template<> struct numeric_info<long double> { enum { min_exp = -308, max_exp = +308}; };
template <typename T>
inline int to_int32(const T v)
{
const typename details::number_type<T>::type num_type;
return to_int32_impl(v, num_type);
}
template <typename T>
inline long long int to_int64(const T v)
{
const typename details::number_type<T>::type num_type;
return to_int64_impl(v, num_type);
}
template <typename T>
inline bool is_nan(const T v)
{
const typename details::number_type<T>::type num_type;
return is_nan_impl(v, num_type);
}
template <typename T>
inline T min(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return min_impl(v0, v1, num_type);
}
template <typename T>
inline T max(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return max_impl(v0, v1, num_type);
}
template <typename T>
inline T equal(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return equal_impl(v0, v1, num_type);
}
template <typename T>
inline T nequal(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return nequal_impl(v0, v1, num_type);
}
template <typename T>
inline T modulus(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return modulus_impl(v0, v1, num_type);
}
template <typename T>
inline T pow(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return pow_impl(v0, v1, num_type);
}
template <typename T>
inline T logn(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return logn_impl(v0, v1, num_type);
}
template <typename T>
inline T root(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return root_impl(v0, v1, num_type);
}
template <typename T>
inline T roundn(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return roundn_impl(v0, v1, num_type);
}
template <typename T>
inline T hypot(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return hypot_impl(v0, v1, num_type);
}
template <typename T>
inline T atan2(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return atan2_impl(v0, v1, num_type);
}
template <typename T>
inline T shr(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return shr_impl(v0, v1, num_type);
}
template <typename T>
inline T shl(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return shl_impl(v0, v1, num_type);
}
template <typename T>
inline T and_opr(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return and_impl(v0, v1, num_type);
}
template <typename T>
inline T nand_opr(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return nand_impl(v0, v1, num_type);
}
template <typename T>
inline T or_opr(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return or_impl(v0, v1, num_type);
}
template <typename T>
inline T nor_opr(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return nor_impl(v0, v1, num_type);
}
template <typename T>
inline T xor_opr(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return xor_impl(v0, v1, num_type);
}
template <typename T>
inline T xnor_opr(const T v0, const T v1)
{
const typename details::number_type<T>::type num_type;
return xnor_impl(v0, v1, num_type);
}
template <typename T>
inline bool is_integer(const T v)
{
const typename details::number_type<T>::type num_type;
return is_integer_impl(v, num_type);
}
template <typename T, unsigned int N>
struct fast_exp
{
static inline T result(T v)
{
unsigned int k = N;
T l = T(1);
while (k)
{
if (k & 1)
{
l *= v;
--k;
}
v *= v;
k >>= 1;
}
return l;
}
};
template <typename T> struct fast_exp<T,10> { static inline T result(T v) { T v_5 = fast_exp<T,5>::result(v); return v_5 * v_5; } };
template <typename T> struct fast_exp<T, 9> { static inline T result(T v) { return fast_exp<T,8>::result(v) * v; } };
template <typename T> struct fast_exp<T, 8> { static inline T result(T v) { T v_4 = fast_exp<T,4>::result(v); return v_4 * v_4; } };
template <typename T> struct fast_exp<T, 7> { static inline T result(T v) { return fast_exp<T,6>::result(v) * v; } };
template <typename T> struct fast_exp<T, 6> { static inline T result(T v) { T v_3 = fast_exp<T,3>::result(v); return v_3 * v_3; } };
template <typename T> struct fast_exp<T, 5> { static inline T result(T v) { return fast_exp<T,4>::result(v) * v; } };
template <typename T> struct fast_exp<T, 4> { static inline T result(T v) { T v_2 = v * v; return v_2 * v_2; } };
template <typename T> struct fast_exp<T, 3> { static inline T result(T v) { return v * v * v; } };
template <typename T> struct fast_exp<T, 2> { static inline T result(T v) { return v * v; } };
template <typename T> struct fast_exp<T, 1> { static inline T result(T v) { return v; } };
template <typename T> struct fast_exp<T, 0> { static inline T result(T ) { return T(1); } };
#define exprtk_define_unary_function(FunctionName) \
template <typename T> \
inline T FunctionName (const T v) \
{ \
const typename details::number_type<T>::type num_type; \
return FunctionName##_impl(v,num_type); \
} \
exprtk_define_unary_function(abs )
exprtk_define_unary_function(acos )
exprtk_define_unary_function(acosh)
exprtk_define_unary_function(asin )
exprtk_define_unary_function(asinh)
exprtk_define_unary_function(atan )
exprtk_define_unary_function(atanh)
exprtk_define_unary_function(ceil )
exprtk_define_unary_function(cos )
exprtk_define_unary_function(cosh )
exprtk_define_unary_function(exp )
exprtk_define_unary_function(expm1)
exprtk_define_unary_function(floor)
exprtk_define_unary_function(log )
exprtk_define_unary_function(log10)
exprtk_define_unary_function(log2 )
exprtk_define_unary_function(log1p)
exprtk_define_unary_function(neg )
exprtk_define_unary_function(pos )
exprtk_define_unary_function(round)
exprtk_define_unary_function(sin )
exprtk_define_unary_function(sinc )
exprtk_define_unary_function(sinh )
exprtk_define_unary_function(sqrt )
exprtk_define_unary_function(tan )
exprtk_define_unary_function(tanh )
exprtk_define_unary_function(cot )
exprtk_define_unary_function(sec )
exprtk_define_unary_function(csc )
exprtk_define_unary_function(r2d )
exprtk_define_unary_function(d2r )
exprtk_define_unary_function(d2g )
exprtk_define_unary_function(g2d )
exprtk_define_unary_function(notl )
exprtk_define_unary_function(sgn )
exprtk_define_unary_function(erf )
exprtk_define_unary_function(erfc )
exprtk_define_unary_function(ncdf )
exprtk_define_unary_function(frac )
exprtk_define_unary_function(trunc)
#undef exprtk_define_unary_function
}
template <typename T>
inline T compute_pow10(T d, const int exponent)
{
static const double fract10[] =
{
0.0,
1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004, 1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008, 1.0E+009, 1.0E+010,
1.0E+011, 1.0E+012, 1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016, 1.0E+017, 1.0E+018, 1.0E+019, 1.0E+020,
1.0E+021, 1.0E+022, 1.0E+023, 1.0E+024, 1.0E+025, 1.0E+026, 1.0E+027, 1.0E+028, 1.0E+029, 1.0E+030,
1.0E+031, 1.0E+032, 1.0E+033, 1.0E+034, 1.0E+035, 1.0E+036, 1.0E+037, 1.0E+038, 1.0E+039, 1.0E+040,
1.0E+041, 1.0E+042, 1.0E+043, 1.0E+044, 1.0E+045, 1.0E+046, 1.0E+047, 1.0E+048, 1.0E+049, 1.0E+050,
1.0E+051, 1.0E+052, 1.0E+053, 1.0E+054, 1.0E+055, 1.0E+056, 1.0E+057, 1.0E+058, 1.0E+059, 1.0E+060,
1.0E+061, 1.0E+062, 1.0E+063, 1.0E+064, 1.0E+065, 1.0E+066, 1.0E+067, 1.0E+068, 1.0E+069, 1.0E+070,
1.0E+071, 1.0E+072, 1.0E+073, 1.0E+074, 1.0E+075, 1.0E+076, 1.0E+077, 1.0E+078, 1.0E+079, 1.0E+080,
1.0E+081, 1.0E+082, 1.0E+083, 1.0E+084, 1.0E+085, 1.0E+086, 1.0E+087, 1.0E+088, 1.0E+089, 1.0E+090,
1.0E+091, 1.0E+092, 1.0E+093, 1.0E+094, 1.0E+095, 1.0E+096, 1.0E+097, 1.0E+098, 1.0E+099, 1.0E+100,
1.0E+101, 1.0E+102, 1.0E+103, 1.0E+104, 1.0E+105, 1.0E+106, 1.0E+107, 1.0E+108, 1.0E+109, 1.0E+110,
1.0E+111, 1.0E+112, 1.0E+113, 1.0E+114, 1.0E+115, 1.0E+116, 1.0E+117, 1.0E+118, 1.0E+119, 1.0E+120,
1.0E+121, 1.0E+122, 1.0E+123, 1.0E+124, 1.0E+125, 1.0E+126, 1.0E+127, 1.0E+128, 1.0E+129, 1.0E+130,
1.0E+131, 1.0E+132, 1.0E+133, 1.0E+134, 1.0E+135, 1.0E+136, 1.0E+137, 1.0E+138, 1.0E+139, 1.0E+140,
1.0E+141, 1.0E+142, 1.0E+143, 1.0E+144, 1.0E+145, 1.0E+146, 1.0E+147, 1.0E+148, 1.0E+149, 1.0E+150,
1.0E+151, 1.0E+152, 1.0E+153, 1.0E+154, 1.0E+155, 1.0E+156, 1.0E+157, 1.0E+158, 1.0E+159, 1.0E+160,
1.0E+161, 1.0E+162, 1.0E+163, 1.0E+164, 1.0E+165, 1.0E+166, 1.0E+167, 1.0E+168, 1.0E+169, 1.0E+170,
1.0E+171, 1.0E+172, 1.0E+173, 1.0E+174, 1.0E+175, 1.0E+176, 1.0E+177, 1.0E+178, 1.0E+179, 1.0E+180,
1.0E+181, 1.0E+182, 1.0E+183, 1.0E+184, 1.0E+185, 1.0E+186, 1.0E+187, 1.0E+188, 1.0E+189, 1.0E+190,
1.0E+191, 1.0E+192, 1.0E+193, 1.0E+194, 1.0E+195, 1.0E+196, 1.0E+197, 1.0E+198, 1.0E+199, 1.0E+200,
1.0E+201, 1.0E+202, 1.0E+203, 1.0E+204, 1.0E+205, 1.0E+206, 1.0E+207, 1.0E+208, 1.0E+209, 1.0E+210,
1.0E+211, 1.0E+212, 1.0E+213, 1.0E+214, 1.0E+215, 1.0E+216, 1.0E+217, 1.0E+218, 1.0E+219, 1.0E+220,
1.0E+221, 1.0E+222, 1.0E+223, 1.0E+224, 1.0E+225, 1.0E+226, 1.0E+227, 1.0E+228, 1.0E+229, 1.0E+230,
1.0E+231, 1.0E+232, 1.0E+233, 1.0E+234, 1.0E+235, 1.0E+236, 1.0E+237, 1.0E+238, 1.0E+239, 1.0E+240,
1.0E+241, 1.0E+242, 1.0E+243, 1.0E+244, 1.0E+245, 1.0E+246, 1.0E+247, 1.0E+248, 1.0E+249, 1.0E+250,
1.0E+251, 1.0E+252, 1.0E+253, 1.0E+254, 1.0E+255, 1.0E+256, 1.0E+257, 1.0E+258, 1.0E+259, 1.0E+260,
1.0E+261, 1.0E+262, 1.0E+263, 1.0E+264, 1.0E+265, 1.0E+266, 1.0E+267, 1.0E+268, 1.0E+269, 1.0E+270,
1.0E+271, 1.0E+272, 1.0E+273, 1.0E+274, 1.0E+275, 1.0E+276, 1.0E+277, 1.0E+278, 1.0E+279, 1.0E+280,
1.0E+281, 1.0E+282, 1.0E+283, 1.0E+284, 1.0E+285, 1.0E+286, 1.0E+287, 1.0E+288, 1.0E+289, 1.0E+290,
1.0E+291, 1.0E+292, 1.0E+293, 1.0E+294, 1.0E+295, 1.0E+296, 1.0E+297, 1.0E+298, 1.0E+299, 1.0E+300,
1.0E+301, 1.0E+302, 1.0E+303, 1.0E+304, 1.0E+305, 1.0E+306, 1.0E+307, 1.0E+308
};
static const int fract10_size = static_cast<int>(sizeof(fract10) / sizeof(double));
const int e = std::abs(exponent);
if (exponent >= std::numeric_limits<T>::min_exponent10)
{
if (e < fract10_size)
{
if (exponent > 0)
return T(d * fract10[e]);
else
return T(d / fract10[e]);
}
else
return T(d * std::pow(10.0, 10.0 * exponent));
}
else
{
d /= T(fract10[ -std::numeric_limits<T>::min_exponent10]);
return T(d / fract10[-exponent + std::numeric_limits<T>::min_exponent10]);
}
}
template <typename Iterator, typename T>
inline bool string_to_type_converter_impl_ref(Iterator& itr, const Iterator end, T& result)
{
if (itr == end)
return false;
const bool negative = ('-' == (*itr));
if (negative || ('+' == (*itr)))
{
if (end == ++itr)
return false;
}
static const uchar_t zero = static_cast<uchar_t>('0');
while ((end != itr) && (zero == (*itr))) ++itr;
bool return_result = true;
unsigned int digit = 0;
const std::size_t length = static_cast<std::size_t>(std::distance(itr,end));
if (length <= 4)
{
exprtk_disable_fallthrough_begin
switch (length)
{
#ifdef exprtk_use_lut
#define exprtk_process_digit \
if ((digit = details::digit_table[(int)*itr++]) < 10) \
result = result * 10 + (digit); \
else \
{ \
return_result = false; \
break; \
} \
#else
#define exprtk_process_digit \
if ((digit = (*itr++ - zero)) < 10) \
result = result * T(10) + digit; \
else \
{ \
return_result = false; \
break; \
} \
#endif
case 4 : exprtk_process_digit
case 3 : exprtk_process_digit
case 2 : exprtk_process_digit
case 1 : if ((digit = (*itr - zero))>= 10) { digit = 0; return_result = false; }
#undef exprtk_process_digit
}
exprtk_disable_fallthrough_end
}
else
return_result = false;
if (length && return_result)
{
result = result * 10 + static_cast<T>(digit);
++itr;
}
result = negative ? -result : result;
return return_result;
}
template <typename Iterator, typename T>
static inline bool parse_nan(Iterator& itr, const Iterator end, T& t)
{
typedef typename std::iterator_traits<Iterator>::value_type type;
static const std::size_t nan_length = 3;
if (std::distance(itr,end) != static_cast<int>(nan_length))
return false;
if (static_cast<type>('n') == (*itr))
{
if (
(static_cast<type>('a') != *(itr + 1)) ||
(static_cast<type>('n') != *(itr + 2))
)
{
return false;
}
}
else if (
(static_cast<type>('A') != *(itr + 1)) ||
(static_cast<type>('N') != *(itr + 2))
)
{
return false;
}
t = std::numeric_limits<T>::quiet_NaN();
return true;
}
template <typename Iterator, typename T>
static inline bool parse_inf(Iterator& itr, const Iterator end, T& t, bool negative)
{
static const char_t inf_uc[] = "INFINITY";
static const char_t inf_lc[] = "infinity";
static const std::size_t inf_length = 8;
const std::size_t length = static_cast<std::size_t>(std::distance(itr,end));
if ((3 != length) && (inf_length != length))
return false;
const char_t* inf_itr = ('i' == (*itr)) ? inf_lc : inf_uc;
while (end != itr)
{
if (*inf_itr == static_cast<char>(*itr))
{
++itr;
++inf_itr;
continue;
}
else
return false;
}
if (negative)
t = -std::numeric_limits<T>::infinity();
else
t = std::numeric_limits<T>::infinity();
return true;
}
template <typename Iterator, typename T>
inline bool string_to_real(Iterator& itr_external, const Iterator end, T& t, numeric::details::real_type_tag)
{
if (end == itr_external) return false;
Iterator itr = itr_external;
T d = T(0);
const bool negative = ('-' == (*itr));
if (negative || '+' == (*itr))
{
if (end == ++itr)
return false;
}
bool instate = false;
static const char zero = static_cast<uchar_t>('0');
#define parse_digit_1(d) \
if ((digit = (*itr - zero)) < 10) \
{ d = d * T(10) + digit; } \
else \
{ break; } \
if (end == ++itr) break; \
#define parse_digit_2(d) \
if ((digit = (*itr - zero)) < 10) \
{ d = d * T(10) + digit; } \
else { break; } \
++itr; \
if ('.' != (*itr))
{
const Iterator curr = itr;
while ((end != itr) && (zero == (*itr))) ++itr;
unsigned int digit;
while (end != itr)
{
// Note: For 'physical' superscalar architectures it
// is advised that the following loop be: 4xPD1 and 1xPD2
#ifdef exprtk_enable_superscalar
parse_digit_1(d)
parse_digit_1(d)
#endif
parse_digit_1(d)
parse_digit_1(d)
parse_digit_2(d)
}
if (curr != itr) instate = true;
}
int exponent = 0;
if (end != itr)
{
if ('.' == (*itr))
{
const Iterator curr = ++itr;
unsigned int digit;
T tmp_d = T(0);
while (end != itr)
{
#ifdef exprtk_enable_superscalar
parse_digit_1(tmp_d)
parse_digit_1(tmp_d)
parse_digit_1(tmp_d)
#endif
parse_digit_1(tmp_d)
parse_digit_1(tmp_d)
parse_digit_2(tmp_d)
}
if (curr != itr)
{
instate = true;
d += compute_pow10(tmp_d,static_cast<int>(-std::distance(curr,itr)));
}
#undef parse_digit_1
#undef parse_digit_2
}
if (end != itr)
{
typename std::iterator_traits<Iterator>::value_type c = (*itr);
if (('e' == c) || ('E' == c))
{
int exp = 0;
if (!details::string_to_type_converter_impl_ref(++itr, end, exp))
{
if (end == itr)
return false;
else
c = (*itr);
}
exponent += exp;
}
if (end != itr)
{
if (('f' == c) || ('F' == c) || ('l' == c) || ('L' == c))
++itr;
else if ('#' == c)
{
if (end == ++itr)
return false;
else if (('I' <= (*itr)) && ((*itr) <= 'n'))
{
if (('i' == (*itr)) || ('I' == (*itr)))
{
return parse_inf(itr, end, t, negative);
}
else if (('n' == (*itr)) || ('N' == (*itr)))
{
return parse_nan(itr, end, t);
}
else
return false;
}
else
return false;
}
else if (('I' <= (*itr)) && ((*itr) <= 'n'))
{
if (('i' == (*itr)) || ('I' == (*itr)))
{
return parse_inf(itr, end, t, negative);
}
else if (('n' == (*itr)) || ('N' == (*itr)))
{
return parse_nan(itr, end, t);
}
else
return false;
}
else
return false;
}
}
}
if ((end != itr) || (!instate))
return false;
else if (exponent)
d = compute_pow10(d,exponent);
t = static_cast<T>((negative) ? -d : d);
return true;
}
template <typename T>
inline bool string_to_real(const std::string& s, T& t)
{
const typename numeric::details::number_type<T>::type num_type;
const char_t* begin = s.data();
const char_t* end = s.data() + s.size();
return string_to_real(begin, end, t, num_type);
}
template <typename T>
struct functor_t
{
/*
Note: The following definitions for Type, may require tweaking
based on the compiler and target architecture. The benchmark
should provide enough information to make the right choice.
*/
//typedef T Type;
//typedef const T Type;
typedef const T& Type;
typedef T& RefType;
typedef T (*qfunc_t)(Type t0, Type t1, Type t2, Type t3);
typedef T (*tfunc_t)(Type t0, Type t1, Type t2);
typedef T (*bfunc_t)(Type t0, Type t1);
typedef T (*ufunc_t)(Type t0);
};
} // namespace details
namespace lexer
{
struct token
{
enum token_type
{
e_none = 0, e_error = 1, e_err_symbol = 2,
e_err_number = 3, e_err_string = 4, e_err_sfunc = 5,
e_eof = 6, e_number = 7, e_symbol = 8,
e_string = 9, e_assign = 10, e_addass = 11,
e_subass = 12, e_mulass = 13, e_divass = 14,
e_modass = 15, e_shr = 16, e_shl = 17,
e_lte = 18, e_ne = 19, e_gte = 20,
e_swap = 21, e_lt = '<', e_gt = '>',
e_eq = '=', e_rbracket = ')', e_lbracket = '(',
e_rsqrbracket = ']', e_lsqrbracket = '[', e_rcrlbracket = '}',
e_lcrlbracket = '{', e_comma = ',', e_add = '+',
e_sub = '-', e_div = '/', e_mul = '*',
e_mod = '%', e_pow = '^', e_colon = ':',
e_ternary = '?'
};
token()
: type(e_none),
value(""),
position(std::numeric_limits<std::size_t>::max())
{}
void clear()
{
type = e_none;
value = "";
position = std::numeric_limits<std::size_t>::max();
}
template <typename Iterator>
inline token& set_operator(const token_type tt,
const Iterator begin, const Iterator end,
const Iterator base_begin = Iterator(0))
{
type = tt;
value.assign(begin,end);
if (base_begin)
position = static_cast<std::size_t>(std::distance(base_begin,begin));
return (*this);
}
template <typename Iterator>
inline token& set_symbol(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
{
type = e_symbol;
value.assign(begin,end);
if (base_begin)
position = static_cast<std::size_t>(std::distance(base_begin,begin));
return (*this);
}
template <typename Iterator>
inline token& set_numeric(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
{
type = e_number;
value.assign(begin,end);
if (base_begin)
position = static_cast<std::size_t>(std::distance(base_begin,begin));
return (*this);
}
template <typename Iterator>
inline token& set_string(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
{
type = e_string;
value.assign(begin,end);
if (base_begin)
position = static_cast<std::size_t>(std::distance(base_begin,begin));
return (*this);
}
inline token& set_string(const std::string& s, const std::size_t p)
{
type = e_string;
value = s;
position = p;
return (*this);
}
template <typename Iterator>
inline token& set_error(const token_type et,
const Iterator begin, const Iterator end,
const Iterator base_begin = Iterator(0))
{
if (
(e_error == et) ||
(e_err_symbol == et) ||
(e_err_number == et) ||
(e_err_string == et) ||
(e_err_sfunc == et)
)
{
type = et;
}
else
type = e_error;
value.assign(begin,end);
if (base_begin)
position = static_cast<std::size_t>(std::distance(base_begin,begin));
return (*this);
}
static inline std::string to_str(token_type t)
{
switch (t)
{
case e_none : return "NONE";
case e_error : return "ERROR";
case e_err_symbol : return "ERROR_SYMBOL";
case e_err_number : return "ERROR_NUMBER";
case e_err_string : return "ERROR_STRING";
case e_eof : return "EOF";
case e_number : return "NUMBER";
case e_symbol : return "SYMBOL";
case e_string : return "STRING";
case e_assign : return ":=";
case e_addass : return "+=";
case e_subass : return "-=";
case e_mulass : return "*=";
case e_divass : return "/=";
case e_modass : return "%=";
case e_shr : return ">>";
case e_shl : return "<<";
case e_lte : return "<=";
case e_ne : return "!=";
case e_gte : return ">=";
case e_lt : return "<";
case e_gt : return ">";
case e_eq : return "=";
case e_rbracket : return ")";
case e_lbracket : return "(";
case e_rsqrbracket : return "]";
case e_lsqrbracket : return "[";
case e_rcrlbracket : return "}";
case e_lcrlbracket : return "{";
case e_comma : return ",";
case e_add : return "+";
case e_sub : return "-";
case e_div : return "/";
case e_mul : return "*";
case e_mod : return "%";
case e_pow : return "^";
case e_colon : return ":";
case e_ternary : return "?";
case e_swap : return "<=>";
default : return "UNKNOWN";
}
}
inline bool is_error() const
{
return (
(e_error == type) ||
(e_err_symbol == type) ||
(e_err_number == type) ||
(e_err_string == type) ||
(e_err_sfunc == type)
);
}
token_type type;
std::string value;
std::size_t position;
};
class generator
{
public:
typedef token token_t;
typedef std::vector<token_t> token_list_t;
typedef std::vector<token_t>::iterator token_list_itr_t;
typedef details::char_t char_t;
generator()
: base_itr_(0),
s_itr_ (0),
s_end_ (0)
{
clear();
}
inline void clear()
{
base_itr_ = 0;
s_itr_ = 0;
s_end_ = 0;
token_list_.clear();
token_itr_ = token_list_.end();
store_token_itr_ = token_list_.end();
}
inline bool process(const std::string& str)
{
base_itr_ = str.data();
s_itr_ = str.data();
s_end_ = str.data() + str.size();
eof_token_.set_operator(token_t::e_eof,s_end_,s_end_,base_itr_);
token_list_.clear();
while (!is_end(s_itr_))
{
scan_token();
if (token_list_.empty())
return true;
else if (token_list_.back().is_error())
return false;
}
return true;
}
inline bool empty() const
{
return token_list_.empty();
}
inline std::size_t size() const
{
return token_list_.size();
}
inline void begin()
{
token_itr_ = token_list_.begin();
store_token_itr_ = token_list_.begin();
}
inline void store()
{
store_token_itr_ = token_itr_;
}
inline void restore()
{
token_itr_ = store_token_itr_;
}
inline token_t& next_token()
{
if (token_list_.end() != token_itr_)
{
return *token_itr_++;
}
else
return eof_token_;
}
inline token_t& peek_next_token()
{
if (token_list_.end() != token_itr_)
{
return *token_itr_;
}
else
return eof_token_;
}
inline token_t& operator[](const std::size_t& index)
{
if (index < token_list_.size())
return token_list_[index];
else
return eof_token_;
}
inline token_t operator[](const std::size_t& index) const
{
if (index < token_list_.size())
return token_list_[index];
else
return eof_token_;
}
inline bool finished() const
{
return (token_list_.end() == token_itr_);
}
inline void insert_front(token_t::token_type tk_type)
{
if (
!token_list_.empty() &&
(token_list_.end() != token_itr_)
)
{
token_t t = *token_itr_;
t.type = tk_type;
token_itr_ = token_list_.insert(token_itr_,t);
}
}
inline std::string substr(const std::size_t& begin, const std::size_t& end)
{
const char_t* begin_itr = ((base_itr_ + begin) < s_end_) ? (base_itr_ + begin) : s_end_;
const char_t* end_itr = ((base_itr_ + end) < s_end_) ? (base_itr_ + end) : s_end_;
return std::string(begin_itr,end_itr);
}
inline std::string remaining() const
{
if (finished())
return "";
else if (token_list_.begin() != token_itr_)
return std::string(base_itr_ + (token_itr_ - 1)->position,s_end_);
else
return std::string(base_itr_ + token_itr_->position,s_end_);
}
private:
inline bool is_end(const char_t* itr)
{
return (s_end_ == itr);
}
inline void skip_whitespace()
{
while (!is_end(s_itr_) && details::is_whitespace(*s_itr_))
{
++s_itr_;
}
}
inline void skip_comments()
{
#ifndef exprtk_disable_comments
// The following comment styles are supported:
// 1. // .... \n
// 2. # .... \n
// 3. /* .... */
struct test
{
static inline bool comment_start(const char_t c0, const char_t c1, int& mode, int& incr)
{
mode = 0;
if ('#' == c0) { mode = 1; incr = 1; }
else if ('/' == c0)
{
if ('/' == c1) { mode = 1; incr = 2; }
else if ('*' == c1) { mode = 2; incr = 2; }
}
return (0 != mode);
}
static inline bool comment_end(const char_t c0, const char_t c1, const int mode)
{
return (
((1 == mode) && ('\n' == c0)) ||
((2 == mode) && ( '*' == c0) && ('/' == c1))
);
}
};
int mode = 0;
int increment = 0;
if (is_end(s_itr_) || is_end((s_itr_ + 1)))
return;
else if (!test::comment_start(*s_itr_, *(s_itr_ + 1), mode, increment))
return;
s_itr_ += increment;
while (!is_end(s_itr_) && !test::comment_end(*s_itr_, *(s_itr_ + 1), mode))
{
++s_itr_;
}
if (!is_end(s_itr_))
{
s_itr_ += mode;
skip_whitespace();
skip_comments ();
}
#endif
}
inline void scan_token()
{
skip_whitespace();
skip_comments ();
if (is_end(s_itr_))
{
return;
}
else if (details::is_operator_char(*s_itr_))
{
scan_operator();
return;
}
else if (details::is_letter(*s_itr_))
{
scan_symbol();
return;
}
else if (details::is_digit((*s_itr_)) || ('.' == (*s_itr_)))
{
scan_number();
return;
}
else if ('$' == (*s_itr_))
{
scan_special_function();
return;
}
#ifndef exprtk_disable_string_capabilities
else if ('\'' == (*s_itr_))
{
scan_string();
return;
}
#endif
else if ('~' == (*s_itr_))
{
token_t t;
t.set_symbol(s_itr_, s_itr_ + 1, base_itr_);
token_list_.push_back(t);
++s_itr_;
return;
}
else
{
token_t t;
t.set_error(token::e_error, s_itr_, s_itr_ + 2, base_itr_);
token_list_.push_back(t);
++s_itr_;
}
}
inline void scan_operator()
{
token_t t;
const char_t c0 = s_itr_[0];
if (!is_end(s_itr_ + 1))
{
const char_t c1 = s_itr_[1];
if (!is_end(s_itr_ + 2))
{
const char_t c2 = s_itr_[2];
if ((c0 == '<') && (c1 == '=') && (c2 == '>'))
{
t.set_operator(token_t::e_swap, s_itr_, s_itr_ + 3, base_itr_);
token_list_.push_back(t);
s_itr_ += 3;
return;
}
}
token_t::token_type ttype = token_t::e_none;
if ((c0 == '<') && (c1 == '=')) ttype = token_t::e_lte;
else if ((c0 == '>') && (c1 == '=')) ttype = token_t::e_gte;
else if ((c0 == '<') && (c1 == '>')) ttype = token_t::e_ne;
else if ((c0 == '!') && (c1 == '=')) ttype = token_t::e_ne;
else if ((c0 == '=') && (c1 == '=')) ttype = token_t::e_eq;
else if ((c0 == ':') && (c1 == '=')) ttype = token_t::e_assign;
else if ((c0 == '<') && (c1 == '<')) ttype = token_t::e_shl;
else if ((c0 == '>') && (c1 == '>')) ttype = token_t::e_shr;
else if ((c0 == '+') && (c1 == '=')) ttype = token_t::e_addass;
else if ((c0 == '-') && (c1 == '=')) ttype = token_t::e_subass;
else if ((c0 == '*') && (c1 == '=')) ttype = token_t::e_mulass;
else if ((c0 == '/') && (c1 == '=')) ttype = token_t::e_divass;
else if ((c0 == '%') && (c1 == '=')) ttype = token_t::e_modass;
if (token_t::e_none != ttype)
{
t.set_operator(ttype, s_itr_, s_itr_ + 2, base_itr_);
token_list_.push_back(t);
s_itr_ += 2;
return;
}
}
if ('<' == c0)
t.set_operator(token_t::e_lt , s_itr_, s_itr_ + 1, base_itr_);
else if ('>' == c0)
t.set_operator(token_t::e_gt , s_itr_, s_itr_ + 1, base_itr_);
else if (';' == c0)
t.set_operator(token_t::e_eof, s_itr_, s_itr_ + 1, base_itr_);
else if ('&' == c0)
t.set_symbol(s_itr_, s_itr_ + 1, base_itr_);
else if ('|' == c0)
t.set_symbol(s_itr_, s_itr_ + 1, base_itr_);
else
t.set_operator(token_t::token_type(c0), s_itr_, s_itr_ + 1, base_itr_);
token_list_.push_back(t);
++s_itr_;
}
inline void scan_symbol()
{
const char_t* initial_itr = s_itr_;
while (!is_end(s_itr_))
{
if (!details::is_letter_or_digit(*s_itr_) && ('_' != (*s_itr_)))
{
if ('.' != (*s_itr_))
break;
/*
Permit symbols that contain a 'dot'
Allowed : abc.xyz, a123.xyz, abc.123, abc_.xyz a123_.xyz abc._123
Disallowed: .abc, abc.<white-space>, abc.<eof>, abc.<operator +,-,*,/...>
*/
if (
(s_itr_ != initial_itr) &&
!is_end(s_itr_ + 1) &&
!details::is_letter_or_digit(*(s_itr_ + 1)) &&
('_' != (*(s_itr_ + 1)))
)
break;
}
++s_itr_;
}
token_t t;
t.set_symbol(initial_itr,s_itr_,base_itr_);
token_list_.push_back(t);
}
inline void scan_number()
{
/*
Attempt to match a valid numeric value in one of the following formats:
(01) 123456
(02) 123456.
(03) 123.456
(04) 123.456e3
(05) 123.456E3
(06) 123.456e+3
(07) 123.456E+3
(08) 123.456e-3
(09) 123.456E-3
(00) .1234
(11) .1234e3
(12) .1234E+3
(13) .1234e+3
(14) .1234E-3
(15) .1234e-3
*/
const char_t* initial_itr = s_itr_;
bool dot_found = false;
bool e_found = false;
bool post_e_sign_found = false;
bool post_e_digit_found = false;
token_t t;
while (!is_end(s_itr_))
{
if ('.' == (*s_itr_))
{
if (dot_found)
{
t.set_error(token::e_err_number, initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
dot_found = true;
++s_itr_;
continue;
}
else if ('e' == std::tolower(*s_itr_))
{
const char_t& c = *(s_itr_ + 1);
if (is_end(s_itr_ + 1))
{
t.set_error(token::e_err_number, initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
else if (
('+' != c) &&
('-' != c) &&
!details::is_digit(c)
)
{
t.set_error(token::e_err_number, initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
e_found = true;
++s_itr_;
continue;
}
else if (e_found && details::is_sign(*s_itr_) && !post_e_digit_found)
{
if (post_e_sign_found)
{
t.set_error(token::e_err_number, initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
post_e_sign_found = true;
++s_itr_;
continue;
}
else if (e_found && details::is_digit(*s_itr_))
{
post_e_digit_found = true;
++s_itr_;
continue;
}
else if (('.' != (*s_itr_)) && !details::is_digit(*s_itr_))
break;
else
++s_itr_;
}
t.set_numeric(initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
inline void scan_special_function()
{
const char_t* initial_itr = s_itr_;
token_t t;
// $fdd(x,x,x) = at least 11 chars
if (std::distance(s_itr_,s_end_) < 11)
{
t.set_error(token::e_err_sfunc, initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
if (
!(('$' == *s_itr_) &&
(details::imatch ('f',*(s_itr_ + 1))) &&
(details::is_digit(*(s_itr_ + 2))) &&
(details::is_digit(*(s_itr_ + 3))))
)
{
t.set_error(token::e_err_sfunc, initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
s_itr_ += 4; // $fdd = 4chars
t.set_symbol(initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
#ifndef exprtk_disable_string_capabilities
inline void scan_string()
{
const char_t* initial_itr = s_itr_ + 1;
token_t t;
if (std::distance(s_itr_,s_end_) < 2)
{
t.set_error(token::e_err_string, s_itr_, s_end_, base_itr_);
token_list_.push_back(t);
return;
}
++s_itr_;
bool escaped_found = false;
bool escaped = false;
while (!is_end(s_itr_))
{
if (!escaped && ('\\' == *s_itr_))
{
escaped_found = true;
escaped = true;
++s_itr_;
continue;
}
else if (!escaped)
{
if ('\'' == *s_itr_)
break;
}
else if (escaped)
{
if (!is_end(s_itr_) && ('0' == *(s_itr_)))
{
/*
Note: The following 'awkward' conditional is
due to various broken msvc compilers.
*/
#if _MSC_VER == 1600
const bool within_range = !is_end(s_itr_ + 2) &&
!is_end(s_itr_ + 3) ;
#else
const bool within_range = !is_end(s_itr_ + 1) &&
!is_end(s_itr_ + 2) &&
!is_end(s_itr_ + 3) ;
#endif
const bool x_seperator = ('x' == *(s_itr_ + 1)) ||
('X' == *(s_itr_ + 1)) ;
const bool both_digits = details::is_hex_digit(*(s_itr_ + 2)) &&
details::is_hex_digit(*(s_itr_ + 3)) ;
if (!within_range || !x_seperator || !both_digits)
{
t.set_error(token::e_err_string, initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
else
s_itr_ += 3;
}
escaped = false;
}
++s_itr_;
}
if (is_end(s_itr_))
{
t.set_error(token::e_err_string, initial_itr, s_itr_, base_itr_);
token_list_.push_back(t);
return;
}
if (!escaped_found)
t.set_string(initial_itr, s_itr_, base_itr_);
else
{
std::string parsed_string(initial_itr,s_itr_);
details::cleanup_escapes(parsed_string);
t.set_string(
parsed_string,
static_cast<std::size_t>(std::distance(base_itr_,initial_itr)));
}
token_list_.push_back(t);
++s_itr_;
return;
}
#endif
private:
token_list_t token_list_;
token_list_itr_t token_itr_;
token_list_itr_t store_token_itr_;
token_t eof_token_;
const char_t* base_itr_;
const char_t* s_itr_;
const char_t* s_end_;
friend class token_scanner;
friend class token_modifier;
friend class token_inserter;
friend class token_joiner;
};
class helper_interface
{
public:
virtual void init() { }
virtual void reset() { }
virtual bool result() { return true; }
virtual std::size_t process(generator&) { return 0; }
virtual ~helper_interface() { }
};
class token_scanner : public helper_interface
{
public:
virtual ~token_scanner()
{}
explicit token_scanner(const std::size_t& stride)
: stride_(stride)
{
if (stride > 4)
{
throw std::invalid_argument("token_scanner() - Invalid stride value");
}
}
inline std::size_t process(generator& g)
{
if (g.token_list_.size() >= stride_)
{
for (std::size_t i = 0; i < (g.token_list_.size() - stride_ + 1); ++i)
{
token t;
switch (stride_)
{
case 1 :
{
const token& t0 = g.token_list_[i];
if (!operator()(t0))
{
return i;
}
}
break;
case 2 :
{
const token& t0 = g.token_list_[i ];
const token& t1 = g.token_list_[i + 1];
if (!operator()(t0, t1))
{
return i;
}
}
break;
case 3 :
{
const token& t0 = g.token_list_[i ];
const token& t1 = g.token_list_[i + 1];
const token& t2 = g.token_list_[i + 2];
if (!operator()(t0, t1, t2))
{
return i;
}
}
break;
case 4 :
{
const token& t0 = g.token_list_[i ];
const token& t1 = g.token_list_[i + 1];
const token& t2 = g.token_list_[i + 2];
const token& t3 = g.token_list_[i + 3];
if (!operator()(t0, t1, t2, t3))
{
return i;
}
}
break;
}
}
}
return (g.token_list_.size() - stride_ + 1);
}
virtual bool operator() (const token&)
{
return false;
}
virtual bool operator() (const token&, const token&)
{
return false;
}
virtual bool operator() (const token&, const token&, const token&)
{
return false;
}
virtual bool operator() (const token&, const token&, const token&, const token&)
{
return false;
}
private:
const std::size_t stride_;
};
class token_modifier : public helper_interface
{
public:
inline std::size_t process(generator& g)
{
std::size_t changes = 0;
for (std::size_t i = 0; i < g.token_list_.size(); ++i)
{
if (modify(g.token_list_[i])) changes++;
}
return changes;
}
virtual bool modify(token& t) = 0;
};
class token_inserter : public helper_interface
{
public:
explicit token_inserter(const std::size_t& stride)
: stride_(stride)
{
if (stride > 5)
{
throw std::invalid_argument("token_inserter() - Invalid stride value");
}
}
inline std::size_t process(generator& g)
{
if (g.token_list_.empty())
return 0;
else if (g.token_list_.size() < stride_)
return 0;
std::size_t changes = 0;
for (std::size_t i = 0; i < (g.token_list_.size() - stride_ + 1); ++i)
{
int insert_index = -1;
token t;
switch (stride_)
{
case 1 : insert_index = insert(g.token_list_[i],t);
break;
case 2 : insert_index = insert(g.token_list_[i], g.token_list_[i + 1], t);
break;
case 3 : insert_index = insert(g.token_list_[i], g.token_list_[i + 1], g.token_list_[i + 2], t);
break;
case 4 : insert_index = insert(g.token_list_[i], g.token_list_[i + 1], g.token_list_[i + 2], g.token_list_[i + 3], t);
break;
case 5 : insert_index = insert(g.token_list_[i], g.token_list_[i + 1], g.token_list_[i + 2], g.token_list_[i + 3], g.token_list_[i + 4], t);
break;
}
typedef std::iterator_traits<generator::token_list_t::iterator>::difference_type diff_t;
if ((insert_index >= 0) && (insert_index <= (static_cast<int>(stride_) + 1)))
{
g.token_list_.insert(
g.token_list_.begin() + static_cast<diff_t>(i + static_cast<std::size_t>(insert_index)), t);
changes++;
}
}
return changes;
}
#define token_inserter_empty_body \
{ \
return -1; \
} \
inline virtual int insert(const token&, token&)
token_inserter_empty_body
inline virtual int insert(const token&, const token&, token&)
token_inserter_empty_body
inline virtual int insert(const token&, const token&, const token&, token&)
token_inserter_empty_body
inline virtual int insert(const token&, const token&, const token&, const token&, token&)
token_inserter_empty_body
inline virtual int insert(const token&, const token&, const token&, const token&, const token&, token&)
token_inserter_empty_body
#undef token_inserter_empty_body
private:
const std::size_t stride_;
};
class token_joiner : public helper_interface
{
public:
token_joiner(const std::size_t& stride)
: stride_(stride)
{}
inline std::size_t process(generator& g)
{
if (g.token_list_.empty())
return 0;
switch (stride_)
{
case 2 : return process_stride_2(g);
case 3 : return process_stride_3(g);
default : return 0;
}
}
virtual bool join(const token&, const token&, token&) { return false; }
virtual bool join(const token&, const token&, const token&, token&) { return false; }
private:
inline std::size_t process_stride_2(generator& g)
{
typedef std::iterator_traits<generator::token_list_t::iterator>::difference_type diff_t;
if (g.token_list_.size() < 2)
return 0;
std::size_t changes = 0;
for (std::size_t i = 0; i < (g.token_list_.size() - 1); ++i)
{
token t;
while (join(g[i], g[i + 1], t))
{
g.token_list_[i] = t;
g.token_list_.erase(g.token_list_.begin() + static_cast<diff_t>(i + 1));
++changes;
}
}
return changes;
}
inline std::size_t process_stride_3(generator& g)
{
typedef std::iterator_traits<generator::token_list_t::iterator>::difference_type diff_t;
if (g.token_list_.size() < 3)
return 0;
std::size_t changes = 0;
for (std::size_t i = 0; i < (g.token_list_.size() - 2); ++i)
{
token t;
while (join(g[i], g[i + 1], g[i + 2], t))
{
g.token_list_[i] = t;
g.token_list_.erase(g.token_list_.begin() + static_cast<diff_t>(i + 1),
g.token_list_.begin() + static_cast<diff_t>(i + 3));
++changes;
}
}
return changes;
}
const std::size_t stride_;
};
namespace helper
{
inline void dump(lexer::generator& generator)
{
for (std::size_t i = 0; i < generator.size(); ++i)
{
lexer::token t = generator[i];
printf("Token[%02d] @ %03d %6s --> '%s'\n",
static_cast<int>(i),
static_cast<int>(t.position),
t.to_str(t.type).c_str(),
t.value.c_str());
}
}
class commutative_inserter : public lexer::token_inserter
{
public:
using lexer::token_inserter::insert;
commutative_inserter()
: lexer::token_inserter(2)
{}
inline void ignore_symbol(const std::string& symbol)
{
ignore_set_.insert(symbol);
}
inline int insert(const lexer::token& t0, const lexer::token& t1, lexer::token& new_token)
{
bool match = false;
new_token.type = lexer::token::e_mul;
new_token.value = "*";
new_token.position = t1.position;
if (t0.type == lexer::token::e_symbol)
{
if (ignore_set_.end() != ignore_set_.find(t0.value))
{
return -1;
}
else if (!t0.value.empty() && ('$' == t0.value[0]))
{
return -1;
}
}
if (t1.type == lexer::token::e_symbol)
{
if (ignore_set_.end() != ignore_set_.find(t1.value))
{
return -1;
}
}
if ((t0.type == lexer::token::e_number ) && (t1.type == lexer::token::e_symbol )) match = true;
else if ((t0.type == lexer::token::e_number ) && (t1.type == lexer::token::e_lbracket )) match = true;
else if ((t0.type == lexer::token::e_number ) && (t1.type == lexer::token::e_lcrlbracket)) match = true;
else if ((t0.type == lexer::token::e_number ) && (t1.type == lexer::token::e_lsqrbracket)) match = true;
else if ((t0.type == lexer::token::e_symbol ) && (t1.type == lexer::token::e_number )) match = true;
else if ((t0.type == lexer::token::e_rbracket ) && (t1.type == lexer::token::e_number )) match = true;
else if ((t0.type == lexer::token::e_rcrlbracket) && (t1.type == lexer::token::e_number )) match = true;
else if ((t0.type == lexer::token::e_rsqrbracket) && (t1.type == lexer::token::e_number )) match = true;
else if ((t0.type == lexer::token::e_rbracket ) && (t1.type == lexer::token::e_symbol )) match = true;
else if ((t0.type == lexer::token::e_rcrlbracket) && (t1.type == lexer::token::e_symbol )) match = true;
else if ((t0.type == lexer::token::e_rsqrbracket) && (t1.type == lexer::token::e_symbol )) match = true;
return (match) ? 1 : -1;
}
private:
std::set<std::string,details::ilesscompare> ignore_set_;
};
class operator_joiner : public token_joiner
{
public:
operator_joiner(const std::size_t& stride)
: token_joiner(stride)
{}
inline bool join(const lexer::token& t0, const lexer::token& t1, lexer::token& t)
{
// ': =' --> ':='
if ((t0.type == lexer::token::e_colon) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_assign;
t.value = ":=";
t.position = t0.position;
return true;
}
// '+ =' --> '+='
else if ((t0.type == lexer::token::e_add) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_addass;
t.value = "+=";
t.position = t0.position;
return true;
}
// '- =' --> '-='
else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_subass;
t.value = "-=";
t.position = t0.position;
return true;
}
// '* =' --> '*='
else if ((t0.type == lexer::token::e_mul) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_mulass;
t.value = "*=";
t.position = t0.position;
return true;
}
// '/ =' --> '/='
else if ((t0.type == lexer::token::e_div) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_divass;
t.value = "/=";
t.position = t0.position;
return true;
}
// '% =' --> '%='
else if ((t0.type == lexer::token::e_mod) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_modass;
t.value = "%=";
t.position = t0.position;
return true;
}
// '> =' --> '>='
else if ((t0.type == lexer::token::e_gt) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_gte;
t.value = ">=";
t.position = t0.position;
return true;
}
// '< =' --> '<='
else if ((t0.type == lexer::token::e_lt) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_lte;
t.value = "<=";
t.position = t0.position;
return true;
}
// '= =' --> '=='
else if ((t0.type == lexer::token::e_eq) && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_eq;
t.value = "==";
t.position = t0.position;
return true;
}
// '! =' --> '!='
else if ((static_cast<char>(t0.type) == '!') && (t1.type == lexer::token::e_eq))
{
t.type = lexer::token::e_ne;
t.value = "!=";
t.position = t0.position;
return true;
}
// '< >' --> '<>'
else if ((t0.type == lexer::token::e_lt) && (t1.type == lexer::token::e_gt))
{
t.type = lexer::token::e_ne;
t.value = "<>";
t.position = t0.position;
return true;
}
// '<= >' --> '<=>'
else if ((t0.type == lexer::token::e_lte) && (t1.type == lexer::token::e_gt))
{
t.type = lexer::token::e_swap;
t.value = "<=>";
t.position = t0.position;
return true;
}
// '+ -' --> '-'
else if ((t0.type == lexer::token::e_add) && (t1.type == lexer::token::e_sub))
{
t.type = lexer::token::e_sub;
t.value = "-";
t.position = t0.position;
return true;
}
// '- +' --> '-'
else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_add))
{
t.type = lexer::token::e_sub;
t.value = "-";
t.position = t0.position;
return true;
}
// '- -' --> '+'
else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_sub))
{
/*
Note: May need to reconsider this when wanting to implement
pre/postfix decrement operator
*/
t.type = lexer::token::e_add;
t.value = "+";
t.position = t0.position;
return true;
}
else
return false;
}
inline bool join(const lexer::token& t0, const lexer::token& t1, const lexer::token& t2, lexer::token& t)
{
// '[ * ]' --> '[*]'
if (
(t0.type == lexer::token::e_lsqrbracket) &&
(t1.type == lexer::token::e_mul ) &&
(t2.type == lexer::token::e_rsqrbracket)
)
{
t.type = lexer::token::e_symbol;
t.value = "[*]";
t.position = t0.position;
return true;
}
else
return false;
}
};
class bracket_checker : public lexer::token_scanner
{
public:
using lexer::token_scanner::operator();
bracket_checker()
: token_scanner(1),
state_(true)
{}
bool result()
{
if (!stack_.empty())
{
lexer::token t;
t.value = stack_.top().first;
t.position = stack_.top().second;
error_token_ = t;
state_ = false;
return false;
}
else
return state_;
}
lexer::token error_token()
{
return error_token_;
}
void reset()
{
// Why? because msvc doesn't support swap properly.
stack_ = std::stack<std::pair<char,std::size_t> >();
state_ = true;
error_token_.clear();
}
bool operator() (const lexer::token& t)
{
if (
!t.value.empty() &&
(lexer::token::e_string != t.type) &&
(lexer::token::e_symbol != t.type) &&
exprtk::details::is_bracket(t.value[0])
)
{
details::char_t c = t.value[0];
if (t.type == lexer::token::e_lbracket ) stack_.push(std::make_pair(')',t.position));
else if (t.type == lexer::token::e_lcrlbracket) stack_.push(std::make_pair('}',t.position));
else if (t.type == lexer::token::e_lsqrbracket) stack_.push(std::make_pair(']',t.position));
else if (exprtk::details::is_right_bracket(c))
{
if (stack_.empty())
{
state_ = false;
error_token_ = t;
return false;
}
else if (c != stack_.top().first)
{
state_ = false;
error_token_ = t;
return false;
}
else
stack_.pop();
}
}
return true;
}
private:
bool state_;
std::stack<std::pair<char,std::size_t> > stack_;
lexer::token error_token_;
};
class numeric_checker : public lexer::token_scanner
{
public:
using lexer::token_scanner::operator();
numeric_checker()
: token_scanner (1),
current_index_(0)
{}
bool result()
{
return error_list_.empty();
}
void reset()
{
error_list_.clear();
current_index_ = 0;
}
bool operator() (const lexer::token& t)
{
if (token::e_number == t.type)
{
double v;
if (!exprtk::details::string_to_real(t.value,v))
{
error_list_.push_back(current_index_);
}
}
++current_index_;
return true;
}
std::size_t error_count() const
{
return error_list_.size();
}
std::size_t error_index(const std::size_t& i)
{
if (i < error_list_.size())
return error_list_[i];
else
return std::numeric_limits<std::size_t>::max();
}
void clear_errors()
{
error_list_.clear();
}
private:
std::size_t current_index_;
std::vector<std::size_t> error_list_;
};
class symbol_replacer : public lexer::token_modifier
{
private:
typedef std::map<std::string,std::pair<std::string,token::token_type>,details::ilesscompare> replace_map_t;
public:
bool remove(const std::string& target_symbol)
{
const replace_map_t::iterator itr = replace_map_.find(target_symbol);
if (replace_map_.end() == itr)
return false;
replace_map_.erase(itr);
return true;
}
bool add_replace(const std::string& target_symbol,
const std::string& replace_symbol,
const lexer::token::token_type token_type = lexer::token::e_symbol)
{
const replace_map_t::iterator itr = replace_map_.find(target_symbol);
if (replace_map_.end() != itr)
{
return false;
}
replace_map_[target_symbol] = std::make_pair(replace_symbol,token_type);
return true;
}
void clear()
{
replace_map_.clear();
}
private:
bool modify(lexer::token& t)
{
if (lexer::token::e_symbol == t.type)
{
if (replace_map_.empty())
return false;
const replace_map_t::iterator itr = replace_map_.find(t.value);
if (replace_map_.end() != itr)
{
t.value = itr->second.first;
t.type = itr->second.second;
return true;
}
}
return false;
}
replace_map_t replace_map_;
};
class sequence_validator : public lexer::token_scanner
{
private:
typedef std::pair<lexer::token::token_type,lexer::token::token_type> token_pair_t;
typedef std::set<token_pair_t> set_t;
public:
using lexer::token_scanner::operator();
sequence_validator()
: lexer::token_scanner(2)
{
add_invalid(lexer::token::e_number ,lexer::token::e_number );
add_invalid(lexer::token::e_string ,lexer::token::e_string );
add_invalid(lexer::token::e_number ,lexer::token::e_string );
add_invalid(lexer::token::e_string ,lexer::token::e_number );
add_invalid_set1(lexer::token::e_assign );
add_invalid_set1(lexer::token::e_shr );
add_invalid_set1(lexer::token::e_shl );
add_invalid_set1(lexer::token::e_lte );
add_invalid_set1(lexer::token::e_ne );
add_invalid_set1(lexer::token::e_gte );
add_invalid_set1(lexer::token::e_lt );
add_invalid_set1(lexer::token::e_gt );
add_invalid_set1(lexer::token::e_eq );
add_invalid_set1(lexer::token::e_comma );
add_invalid_set1(lexer::token::e_add );
add_invalid_set1(lexer::token::e_sub );
add_invalid_set1(lexer::token::e_div );
add_invalid_set1(lexer::token::e_mul );
add_invalid_set1(lexer::token::e_mod );
add_invalid_set1(lexer::token::e_pow );
add_invalid_set1(lexer::token::e_colon );
add_invalid_set1(lexer::token::e_ternary);
}
bool result()
{
return error_list_.empty();
}
bool operator() (const lexer::token& t0, const lexer::token& t1)
{
set_t::value_type p = std::make_pair(t0.type,t1.type);
if (invalid_bracket_check(t0.type,t1.type))
{
error_list_.push_back(std::make_pair(t0,t1));
}
else if (invalid_comb_.find(p) != invalid_comb_.end())
{
error_list_.push_back(std::make_pair(t0,t1));
}
return true;
}
std::size_t error_count()
{
return error_list_.size();
}
std::pair<lexer::token,lexer::token> error(const std::size_t index)
{
if (index < error_list_.size())
{
return error_list_[index];
}
else
{
static const lexer::token error_token;
return std::make_pair(error_token,error_token);
}
}
void clear_errors()
{
error_list_.clear();
}
private:
void add_invalid(lexer::token::token_type base, lexer::token::token_type t)
{
invalid_comb_.insert(std::make_pair(base,t));
}
void add_invalid_set1(lexer::token::token_type t)
{
add_invalid(t,lexer::token::e_assign);
add_invalid(t,lexer::token::e_shr );
add_invalid(t,lexer::token::e_shl );
add_invalid(t,lexer::token::e_lte );
add_invalid(t,lexer::token::e_ne );
add_invalid(t,lexer::token::e_gte );
add_invalid(t,lexer::token::e_lt );
add_invalid(t,lexer::token::e_gt );
add_invalid(t,lexer::token::e_eq );
add_invalid(t,lexer::token::e_comma );
add_invalid(t,lexer::token::e_div );
add_invalid(t,lexer::token::e_mul );
add_invalid(t,lexer::token::e_mod );
add_invalid(t,lexer::token::e_pow );
add_invalid(t,lexer::token::e_colon );
}
bool invalid_bracket_check(lexer::token::token_type base, lexer::token::token_type t)
{
if (details::is_right_bracket(static_cast<char>(base)))
{
switch (t)
{
case lexer::token::e_assign : return (']' != base);
case lexer::token::e_string : return true;
default : return false;
}
}
else if (details::is_left_bracket(static_cast<char>(base)))
{
if (details::is_right_bracket(static_cast<char>(t)))
return false;
else if (details::is_left_bracket(static_cast<char>(t)))
return false;
else
{
switch (t)
{
case lexer::token::e_number : return false;
case lexer::token::e_symbol : return false;
case lexer::token::e_string : return false;
case lexer::token::e_add : return false;
case lexer::token::e_sub : return false;
case lexer::token::e_colon : return false;
case lexer::token::e_ternary : return false;
default : return true;
}
}
}
else if (details::is_right_bracket(static_cast<char>(t)))
{
switch (base)
{
case lexer::token::e_number : return false;
case lexer::token::e_symbol : return false;
case lexer::token::e_string : return false;
case lexer::token::e_eof : return false;
case lexer::token::e_colon : return false;
case lexer::token::e_ternary : return false;
default : return true;
}
}
else if (details::is_left_bracket(static_cast<char>(t)))
{
switch (base)
{
case lexer::token::e_rbracket : return true;
case lexer::token::e_rsqrbracket : return true;
case lexer::token::e_rcrlbracket : return true;
default : return false;
}
}
return false;
}
set_t invalid_comb_;
std::vector<std::pair<lexer::token,lexer::token> > error_list_;
};
struct helper_assembly
{
inline bool register_scanner(lexer::token_scanner* scanner)
{
if (token_scanner_list.end() != std::find(token_scanner_list.begin(),
token_scanner_list.end (),
scanner))
{
return false;
}
token_scanner_list.push_back(scanner);
return true;
}
inline bool register_modifier(lexer::token_modifier* modifier)
{
if (token_modifier_list.end() != std::find(token_modifier_list.begin(),
token_modifier_list.end (),
modifier))
{
return false;
}
token_modifier_list.push_back(modifier);
return true;
}
inline bool register_joiner(lexer::token_joiner* joiner)
{
if (token_joiner_list.end() != std::find(token_joiner_list.begin(),
token_joiner_list.end (),
joiner))
{
return false;
}
token_joiner_list.push_back(joiner);
return true;
}
inline bool register_inserter(lexer::token_inserter* inserter)
{
if (token_inserter_list.end() != std::find(token_inserter_list.begin(),
token_inserter_list.end (),
inserter))
{
return false;
}
token_inserter_list.push_back(inserter);
return true;
}
inline bool run_modifiers(lexer::generator& g)
{
error_token_modifier = reinterpret_cast<lexer::token_modifier*>(0);
for (std::size_t i = 0; i < token_modifier_list.size(); ++i)
{
lexer::token_modifier& modifier = (*token_modifier_list[i]);
modifier.reset();
modifier.process(g);
if (!modifier.result())
{
error_token_modifier = token_modifier_list[i];
return false;
}
}
return true;
}
inline bool run_joiners(lexer::generator& g)
{
error_token_joiner = reinterpret_cast<lexer::token_joiner*>(0);
for (std::size_t i = 0; i < token_joiner_list.size(); ++i)
{
lexer::token_joiner& joiner = (*token_joiner_list[i]);
joiner.reset();
joiner.process(g);
if (!joiner.result())
{
error_token_joiner = token_joiner_list[i];
return false;
}
}
return true;
}
inline bool run_inserters(lexer::generator& g)
{
error_token_inserter = reinterpret_cast<lexer::token_inserter*>(0);
for (std::size_t i = 0; i < token_inserter_list.size(); ++i)
{
lexer::token_inserter& inserter = (*token_inserter_list[i]);
inserter.reset();
inserter.process(g);
if (!inserter.result())
{
error_token_inserter = token_inserter_list[i];
return false;
}
}
return true;
}
inline bool run_scanners(lexer::generator& g)
{
error_token_scanner = reinterpret_cast<lexer::token_scanner*>(0);
for (std::size_t i = 0; i < token_scanner_list.size(); ++i)
{
lexer::token_scanner& scanner = (*token_scanner_list[i]);
scanner.reset();
scanner.process(g);
if (!scanner.result())
{
error_token_scanner = token_scanner_list[i];
return false;
}
}
return true;
}
std::vector<lexer::token_scanner*> token_scanner_list;
std::vector<lexer::token_modifier*> token_modifier_list;
std::vector<lexer::token_joiner*> token_joiner_list;
std::vector<lexer::token_inserter*> token_inserter_list;
lexer::token_scanner* error_token_scanner;
lexer::token_modifier* error_token_modifier;
lexer::token_joiner* error_token_joiner;
lexer::token_inserter* error_token_inserter;
};
}
class parser_helper
{
public:
typedef token token_t;
typedef generator generator_t;
inline bool init(const std::string& str)
{
if (!lexer_.process(str))
{
return false;
}
lexer_.begin();
next_token();
return true;
}
inline generator_t& lexer()
{
return lexer_;
}
inline const generator_t& lexer() const
{
return lexer_;
}
inline void store_token()
{
lexer_.store();
store_current_token_ = current_token_;
}
inline void restore_token()
{
lexer_.restore();
current_token_ = store_current_token_;
}
inline void next_token()
{
current_token_ = lexer_.next_token();
}
inline const token_t& current_token() const
{
return current_token_;
}
enum token_advance_mode
{
e_hold = 0,
e_advance = 1
};
inline void advance_token(const token_advance_mode mode)
{
if (e_advance == mode)
{
next_token();
}
}
inline bool token_is(const token_t::token_type& ttype, const token_advance_mode mode = e_advance)
{
if (current_token().type != ttype)
{
return false;
}
advance_token(mode);
return true;
}
inline bool token_is(const token_t::token_type& ttype,
const std::string& value,
const token_advance_mode mode = e_advance)
{
if (
(current_token().type != ttype) ||
!exprtk::details::imatch(value,current_token().value)
)
{
return false;
}
advance_token(mode);
return true;
}
inline bool token_is_then_assign(const token_t::token_type& ttype,
std::string& token,
const token_advance_mode mode = e_advance)
{
if (current_token_.type != ttype)
{
return false;
}
token = current_token_.value;
advance_token(mode);
return true;
}
template <typename Allocator,
template <typename,typename> class Container>
inline bool token_is_then_assign(const token_t::token_type& ttype,
Container<std::string,Allocator>& token_list,
const token_advance_mode mode = e_advance)
{
if (current_token_.type != ttype)
{
return false;
}
token_list.push_back(current_token_.value);
advance_token(mode);
return true;
}
inline bool peek_token_is(const token_t::token_type& ttype)
{
return (lexer_.peek_next_token().type == ttype);
}
inline bool peek_token_is(const std::string& s)
{
return (exprtk::details::imatch(lexer_.peek_next_token().value,s));
}
private:
generator_t lexer_;
token_t current_token_;
token_t store_current_token_;
};
}
template <typename T>
class vector_view
{
public:
typedef T* data_ptr_t;
vector_view(data_ptr_t data, const std::size_t& size)
: size_(size),
data_(data),
data_ref_(0)
{}
vector_view(const vector_view<T>& vv)
: size_(vv.size_),
data_(vv.data_),
data_ref_(0)
{}
inline void rebase(data_ptr_t data)
{
data_ = data;
if (!data_ref_.empty())
{
for (std::size_t i = 0; i < data_ref_.size(); ++i)
{
(*data_ref_[i]) = data;
}
}
}
inline data_ptr_t data() const
{
return data_;
}
inline std::size_t size() const
{
return size_;
}
inline const T& operator[](const std::size_t index) const
{
return data_[index];
}
inline T& operator[](const std::size_t index)
{
return data_[index];
}
void set_ref(data_ptr_t* data_ref)
{
data_ref_.push_back(data_ref);
}
private:
const std::size_t size_;
data_ptr_t data_;
std::vector<data_ptr_t*> data_ref_;
};
template <typename T>
inline vector_view<T> make_vector_view(T* data,
const std::size_t size, const std::size_t offset = 0)
{
return vector_view<T>(data + offset,size);
}
template <typename T>
inline vector_view<T> make_vector_view(std::vector<T>& v,
const std::size_t size, const std::size_t offset = 0)
{
return vector_view<T>(v.data() + offset,size);
}
template <typename T> class results_context;
template <typename T>
struct type_store
{
enum store_type
{
e_unknown,
e_scalar ,
e_vector ,
e_string
};
type_store()
: size(0),
data(0),
type(e_unknown)
{}
std::size_t size;
void* data;
store_type type;
class parameter_list
{
public:
parameter_list(std::vector<type_store>& pl)
: parameter_list_(pl)
{}
inline bool empty() const
{
return parameter_list_.empty();
}
inline std::size_t size() const
{
return parameter_list_.size();
}
inline type_store& operator[](const std::size_t& index)
{
return parameter_list_[index];
}
inline const type_store& operator[](const std::size_t& index) const
{
return parameter_list_[index];
}
inline type_store& front()
{
return parameter_list_[0];
}
inline const type_store& front() const
{
return parameter_list_[0];
}
inline type_store& back()
{
return parameter_list_.back();
}
inline const type_store& back() const
{
return parameter_list_.back();
}
private:
std::vector<type_store>& parameter_list_;
friend class results_context<T>;
};
template <typename ViewType>
struct type_view
{
typedef type_store<T> type_store_t;
typedef ViewType value_t;
type_view(type_store_t& ts)
: ts_(ts),
data_(reinterpret_cast<value_t*>(ts_.data))
{}
type_view(const type_store_t& ts)
: ts_(const_cast<type_store_t&>(ts)),
data_(reinterpret_cast<value_t*>(ts_.data))
{}
inline std::size_t size() const
{
return ts_.size;
}
inline value_t& operator[](const std::size_t& i)
{
return data_[i];
}
inline const value_t& operator[](const std::size_t& i) const
{
return data_[i];
}
inline const value_t* begin() const { return data_; }
inline value_t* begin() { return data_; }
inline const value_t* end() const
{
return static_cast<value_t*>(data_ + ts_.size);
}
inline value_t* end()
{
return static_cast<value_t*>(data_ + ts_.size);
}
type_store_t& ts_;
value_t* data_;
};
typedef type_view<T> vector_view;
typedef type_view<char> string_view;
struct scalar_view
{
typedef type_store<T> type_store_t;
typedef T value_t;
scalar_view(type_store_t& ts)
: v_(*reinterpret_cast<value_t*>(ts.data))
{}
scalar_view(const type_store_t& ts)
: v_(*reinterpret_cast<value_t*>(const_cast<type_store_t&>(ts).data))
{}
inline value_t& operator() ()
{
return v_;
}
inline const value_t& operator() () const
{
return v_;
}
template <typename IntType>
inline bool to_int(IntType& i) const
{
if (!exprtk::details::numeric::is_integer(v_))
return false;
i = static_cast<IntType>(v_);
return true;
}
template <typename UIntType>
inline bool to_uint(UIntType& u) const
{
if (v_ < T(0))
return false;
else if (!exprtk::details::numeric::is_integer(v_))
return false;
u = static_cast<UIntType>(v_);
return true;
}
T& v_;
};
};
template <typename StringView>
inline std::string to_str(const StringView& view)
{
return std::string(view.begin(),view.size());
}
#ifndef exprtk_disable_return_statement
namespace details
{
template <typename T> class return_node;
template <typename T> class return_envelope_node;
}
#endif
template <typename T>
class results_context
{
public:
typedef type_store<T> type_store_t;
results_context()
: results_available_(false)
{}
inline std::size_t count() const
{
if (results_available_)
return parameter_list_.size();
else
return 0;
}
inline type_store_t& operator[](const std::size_t& index)
{
return parameter_list_[index];
}
inline const type_store_t& operator[](const std::size_t& index) const
{
return parameter_list_[index];
}
private:
inline void clear()
{
results_available_ = false;
}
typedef std::vector<type_store_t> ts_list_t;
typedef typename type_store_t::parameter_list parameter_list_t;
inline void assign(const parameter_list_t& pl)
{
parameter_list_ = pl.parameter_list_;
results_available_ = true;
}
bool results_available_;
ts_list_t parameter_list_;
#ifndef exprtk_disable_return_statement
friend class details::return_node<T>;
friend class details::return_envelope_node<T>;
#endif
};
namespace details
{
enum operator_type
{
e_default , e_null , e_add , e_sub ,
e_mul , e_div , e_mod , e_pow ,
e_atan2 , e_min , e_max , e_avg ,
e_sum , e_prod , e_lt , e_lte ,
e_eq , e_equal , e_ne , e_nequal ,
e_gte , e_gt , e_and , e_nand ,
e_or , e_nor , e_xor , e_xnor ,
e_mand , e_mor , e_scand , e_scor ,
e_shr , e_shl , e_abs , e_acos ,
e_acosh , e_asin , e_asinh , e_atan ,
e_atanh , e_ceil , e_cos , e_cosh ,
e_exp , e_expm1 , e_floor , e_log ,
e_log10 , e_log2 , e_log1p , e_logn ,
e_neg , e_pos , e_round , e_roundn ,
e_root , e_sqrt , e_sin , e_sinc ,
e_sinh , e_sec , e_csc , e_tan ,
e_tanh , e_cot , e_clamp , e_iclamp ,
e_inrange , e_sgn , e_r2d , e_d2r ,
e_d2g , e_g2d , e_hypot , e_notl ,
e_erf , e_erfc , e_ncdf , e_frac ,
e_trunc , e_assign , e_addass , e_subass ,
e_mulass , e_divass , e_modass , e_in ,
e_like , e_ilike , e_multi , e_smulti ,
e_swap ,
// Do not add new functions/operators after this point.
e_sf00 = 1000, e_sf01 = 1001, e_sf02 = 1002, e_sf03 = 1003,
e_sf04 = 1004, e_sf05 = 1005, e_sf06 = 1006, e_sf07 = 1007,
e_sf08 = 1008, e_sf09 = 1009, e_sf10 = 1010, e_sf11 = 1011,
e_sf12 = 1012, e_sf13 = 1013, e_sf14 = 1014, e_sf15 = 1015,
e_sf16 = 1016, e_sf17 = 1017, e_sf18 = 1018, e_sf19 = 1019,
e_sf20 = 1020, e_sf21 = 1021, e_sf22 = 1022, e_sf23 = 1023,
e_sf24 = 1024, e_sf25 = 1025, e_sf26 = 1026, e_sf27 = 1027,
e_sf28 = 1028, e_sf29 = 1029, e_sf30 = 1030, e_sf31 = 1031,
e_sf32 = 1032, e_sf33 = 1033, e_sf34 = 1034, e_sf35 = 1035,
e_sf36 = 1036, e_sf37 = 1037, e_sf38 = 1038, e_sf39 = 1039,
e_sf40 = 1040, e_sf41 = 1041, e_sf42 = 1042, e_sf43 = 1043,
e_sf44 = 1044, e_sf45 = 1045, e_sf46 = 1046, e_sf47 = 1047,
e_sf48 = 1048, e_sf49 = 1049, e_sf50 = 1050, e_sf51 = 1051,
e_sf52 = 1052, e_sf53 = 1053, e_sf54 = 1054, e_sf55 = 1055,
e_sf56 = 1056, e_sf57 = 1057, e_sf58 = 1058, e_sf59 = 1059,
e_sf60 = 1060, e_sf61 = 1061, e_sf62 = 1062, e_sf63 = 1063,
e_sf64 = 1064, e_sf65 = 1065, e_sf66 = 1066, e_sf67 = 1067,
e_sf68 = 1068, e_sf69 = 1069, e_sf70 = 1070, e_sf71 = 1071,
e_sf72 = 1072, e_sf73 = 1073, e_sf74 = 1074, e_sf75 = 1075,
e_sf76 = 1076, e_sf77 = 1077, e_sf78 = 1078, e_sf79 = 1079,
e_sf80 = 1080, e_sf81 = 1081, e_sf82 = 1082, e_sf83 = 1083,
e_sf84 = 1084, e_sf85 = 1085, e_sf86 = 1086, e_sf87 = 1087,
e_sf88 = 1088, e_sf89 = 1089, e_sf90 = 1090, e_sf91 = 1091,
e_sf92 = 1092, e_sf93 = 1093, e_sf94 = 1094, e_sf95 = 1095,
e_sf96 = 1096, e_sf97 = 1097, e_sf98 = 1098, e_sf99 = 1099,
e_sffinal = 1100,
e_sf4ext00 = 2000, e_sf4ext01 = 2001, e_sf4ext02 = 2002, e_sf4ext03 = 2003,
e_sf4ext04 = 2004, e_sf4ext05 = 2005, e_sf4ext06 = 2006, e_sf4ext07 = 2007,
e_sf4ext08 = 2008, e_sf4ext09 = 2009, e_sf4ext10 = 2010, e_sf4ext11 = 2011,
e_sf4ext12 = 2012, e_sf4ext13 = 2013, e_sf4ext14 = 2014, e_sf4ext15 = 2015,
e_sf4ext16 = 2016, e_sf4ext17 = 2017, e_sf4ext18 = 2018, e_sf4ext19 = 2019,
e_sf4ext20 = 2020, e_sf4ext21 = 2021, e_sf4ext22 = 2022, e_sf4ext23 = 2023,
e_sf4ext24 = 2024, e_sf4ext25 = 2025, e_sf4ext26 = 2026, e_sf4ext27 = 2027,
e_sf4ext28 = 2028, e_sf4ext29 = 2029, e_sf4ext30 = 2030, e_sf4ext31 = 2031,
e_sf4ext32 = 2032, e_sf4ext33 = 2033, e_sf4ext34 = 2034, e_sf4ext35 = 2035,
e_sf4ext36 = 2036, e_sf4ext37 = 2037, e_sf4ext38 = 2038, e_sf4ext39 = 2039,
e_sf4ext40 = 2040, e_sf4ext41 = 2041, e_sf4ext42 = 2042, e_sf4ext43 = 2043,
e_sf4ext44 = 2044, e_sf4ext45 = 2045, e_sf4ext46 = 2046, e_sf4ext47 = 2047,
e_sf4ext48 = 2048, e_sf4ext49 = 2049, e_sf4ext50 = 2050, e_sf4ext51 = 2051,
e_sf4ext52 = 2052, e_sf4ext53 = 2053, e_sf4ext54 = 2054, e_sf4ext55 = 2055,
e_sf4ext56 = 2056, e_sf4ext57 = 2057, e_sf4ext58 = 2058, e_sf4ext59 = 2059,
e_sf4ext60 = 2060, e_sf4ext61 = 2061
};
inline std::string to_str(const operator_type opr)
{
switch (opr)
{
case e_add : return "+";
case e_sub : return "-";
case e_mul : return "*";
case e_div : return "/";
case e_mod : return "%";
case e_pow : return "^";
case e_assign : return ":=";
case e_addass : return "+=";
case e_subass : return "-=";
case e_mulass : return "*=";
case e_divass : return "/=";
case e_modass : return "%=";
case e_lt : return "<";
case e_lte : return "<=";
case e_eq : return "==";
case e_equal : return "=";
case e_ne : return "!=";
case e_nequal : return "<>";
case e_gte : return ">=";
case e_gt : return ">";
default : return"N/A";
}
}
struct base_operation_t
{
base_operation_t(const operator_type t, const unsigned int& np)
: type(t),
num_params(np)
{}
operator_type type;
unsigned int num_params;
};
namespace loop_unroll
{
#ifndef exprtk_disable_superscalar_unroll
const unsigned int global_loop_batch_size = 16;
#else
const unsigned int global_loop_batch_size = 4;
#endif
struct details
{
details(const std::size_t& vsize,
const unsigned int loop_batch_size = global_loop_batch_size)
: batch_size(loop_batch_size ),
remainder (vsize % batch_size),
upper_bound(static_cast<int>(vsize - (remainder ? loop_batch_size : 0)))
{}
unsigned int batch_size;
int remainder;
int upper_bound;
};
}
#ifdef exprtk_enable_debugging
inline void dump_ptr(const std::string& s, const void* ptr, const std::size_t size = 0)
{
if (size)
exprtk_debug(("%s - addr: %p\n",s.c_str(),ptr));
else
exprtk_debug(("%s - addr: %p size: %d\n",
s.c_str(),
ptr,
static_cast<unsigned int>(size)));
}
#else
inline void dump_ptr(const std::string&, const void*) {}
inline void dump_ptr(const std::string&, const void*, const std::size_t) {}
#endif
template <typename T>
class vec_data_store
{
public:
typedef vec_data_store<T> type;
typedef T* data_t;
private:
struct control_block
{
control_block()
: ref_count(1),
size (0),
data (0),
destruct (true)
{}
control_block(const std::size_t& dsize)
: ref_count(1),
size (dsize),
data (0),
destruct (true)
{ create_data(); }
control_block(const std::size_t& dsize, data_t dptr, bool dstrct = false)
: ref_count(1),
size (dsize),
data (dptr ),
destruct (dstrct)
{}
~control_block()
{
if (data && destruct && (0 == ref_count))
{
dump_ptr("~control_block() data",data);
delete[] data;
data = reinterpret_cast<data_t>(0);
}
}
static inline control_block* create(const std::size_t& dsize, data_t data_ptr = data_t(0), bool dstrct = false)
{
if (dsize)
{
if (0 == data_ptr)
return (new control_block(dsize));
else
return (new control_block(dsize, data_ptr, dstrct));
}
else
return (new control_block);
}
static inline void destroy(control_block*& cntrl_blck)
{
if (cntrl_blck)
{
if (
(0 != cntrl_blck->ref_count) &&
(0 == --cntrl_blck->ref_count)
)
{
delete cntrl_blck;
}
cntrl_blck = 0;
}
}
std::size_t ref_count;
std::size_t size;
data_t data;
bool destruct;
private:
control_block(const control_block&);
control_block& operator=(const control_block&);
inline void create_data()
{
destruct = true;
data = new T[size];
std::fill_n(data,size,T(0));
dump_ptr("control_block::create_data() - data",data,size);
}
};
public:
vec_data_store()
: control_block_(control_block::create(0))
{}
vec_data_store(const std::size_t& size)
: control_block_(control_block::create(size,(data_t)(0),true))
{}
vec_data_store(const std::size_t& size, data_t data, bool dstrct = false)
: control_block_(control_block::create(size, data, dstrct))
{}
vec_data_store(const type& vds)
{
control_block_ = vds.control_block_;
control_block_->ref_count++;
}
~vec_data_store()
{
control_block::destroy(control_block_);
}
type& operator=(const type& vds)
{
if (this != &vds)
{
std::size_t final_size = min_size(control_block_, vds.control_block_);
vds.control_block_->size = final_size;
control_block_->size = final_size;
if (control_block_->destruct || (0 == control_block_->data))
{
control_block::destroy(control_block_);
control_block_ = vds.control_block_;
control_block_->ref_count++;
}
}
return (*this);
}
inline data_t data()
{
return control_block_->data;
}
inline data_t data() const
{
return control_block_->data;
}
inline std::size_t size()
{
return control_block_->size;
}
inline std::size_t size() const
{
return control_block_->size;
}
inline data_t& ref()
{
return control_block_->data;
}
inline void dump() const
{
#ifdef exprtk_enable_debugging
exprtk_debug(("size: %d\taddress:%p\tdestruct:%c\n",
size(),
data(),
(control_block_->destruct ? 'T' : 'F')));
for (std::size_t i = 0; i < size(); ++i)
{
if (5 == i)
exprtk_debug(("\n"));
exprtk_debug(("%15.10f ",data()[i]));
}
exprtk_debug(("\n"));
#endif
}
static inline void match_sizes(type& vds0, type& vds1)
{
std::size_t size = min_size(vds0.control_block_,vds1.control_block_);
vds0.control_block_->size = size;
vds1.control_block_->size = size;
}
private:
static inline std::size_t min_size(control_block* cb0, control_block* cb1)
{
std::size_t size0 = cb0->size;
std::size_t size1 = cb1->size;
if (size0 && size1)
return std::min(size0,size1);
else
return (size0) ? size0 : size1;
}
control_block* control_block_;
};
namespace numeric
{
namespace details
{
template <typename T>
inline T process_impl(const operator_type operation, const T arg)
{
switch (operation)
{
case e_abs : return numeric::abs (arg);
case e_acos : return numeric::acos (arg);
case e_acosh : return numeric::acosh(arg);
case e_asin : return numeric::asin (arg);
case e_asinh : return numeric::asinh(arg);
case e_atan : return numeric::atan (arg);
case e_atanh : return numeric::atanh(arg);
case e_ceil : return numeric::ceil (arg);
case e_cos : return numeric::cos (arg);
case e_cosh : return numeric::cosh (arg);
case e_exp : return numeric::exp (arg);
case e_expm1 : return numeric::expm1(arg);
case e_floor : return numeric::floor(arg);
case e_log : return numeric::log (arg);
case e_log10 : return numeric::log10(arg);
case e_log2 : return numeric::log2 (arg);
case e_log1p : return numeric::log1p(arg);
case e_neg : return numeric::neg (arg);
case e_pos : return numeric::pos (arg);
case e_round : return numeric::round(arg);
case e_sin : return numeric::sin (arg);
case e_sinc : return numeric::sinc (arg);
case e_sinh : return numeric::sinh (arg);
case e_sqrt : return numeric::sqrt (arg);
case e_tan : return numeric::tan (arg);
case e_tanh : return numeric::tanh (arg);
case e_cot : return numeric::cot (arg);
case e_sec : return numeric::sec (arg);
case e_csc : return numeric::csc (arg);
case e_r2d : return numeric::r2d (arg);
case e_d2r : return numeric::d2r (arg);
case e_d2g : return numeric::d2g (arg);
case e_g2d : return numeric::g2d (arg);
case e_notl : return numeric::notl (arg);
case e_sgn : return numeric::sgn (arg);
case e_erf : return numeric::erf (arg);
case e_erfc : return numeric::erfc (arg);
case e_ncdf : return numeric::ncdf (arg);
case e_frac : return numeric::frac (arg);
case e_trunc : return numeric::trunc(arg);
default : exprtk_debug(("numeric::details::process_impl<T> - Invalid unary operation.\n"));
return std::numeric_limits<T>::quiet_NaN();
}
}
template <typename T>
inline T process_impl(const operator_type operation, const T arg0, const T arg1)
{
switch (operation)
{
case e_add : return (arg0 + arg1);
case e_sub : return (arg0 - arg1);
case e_mul : return (arg0 * arg1);
case e_div : return (arg0 / arg1);
case e_mod : return modulus<T>(arg0,arg1);
case e_pow : return pow<T>(arg0,arg1);
case e_atan2 : return atan2<T>(arg0,arg1);
case e_min : return std::min<T>(arg0,arg1);
case e_max : return std::max<T>(arg0,arg1);
case e_logn : return logn<T>(arg0,arg1);
case e_lt : return (arg0 < arg1) ? T(1) : T(0);
case e_lte : return (arg0 <= arg1) ? T(1) : T(0);
case e_eq : return std::equal_to<T>()(arg0,arg1) ? T(1) : T(0);
case e_ne : return std::not_equal_to<T>()(arg0,arg1) ? T(1) : T(0);
case e_gte : return (arg0 >= arg1) ? T(1) : T(0);
case e_gt : return (arg0 > arg1) ? T(1) : T(0);
case e_and : return and_opr<T> (arg0,arg1);
case e_nand : return nand_opr<T>(arg0,arg1);
case e_or : return or_opr<T> (arg0,arg1);
case e_nor : return nor_opr<T> (arg0,arg1);
case e_xor : return xor_opr<T> (arg0,arg1);
case e_xnor : return xnor_opr<T>(arg0,arg1);
case e_root : return root<T> (arg0,arg1);
case e_roundn : return roundn<T> (arg0,arg1);
case e_equal : return equal (arg0,arg1);
case e_nequal : return nequal (arg0,arg1);
case e_hypot : return hypot<T> (arg0,arg1);
case e_shr : return shr<T> (arg0,arg1);
case e_shl : return shl<T> (arg0,arg1);
default : exprtk_debug(("numeric::details::process_impl<T> - Invalid binary operation.\n"));
return std::numeric_limits<T>::quiet_NaN();
}
}
template <typename T>
inline T process_impl(const operator_type operation, const T arg0, const T arg1, int_type_tag)
{
switch (operation)
{
case e_add : return (arg0 + arg1);
case e_sub : return (arg0 - arg1);
case e_mul : return (arg0 * arg1);
case e_div : return (arg0 / arg1);
case e_mod : return arg0 % arg1;
case e_pow : return pow<T>(arg0,arg1);
case e_min : return std::min<T>(arg0,arg1);
case e_max : return std::max<T>(arg0,arg1);
case e_logn : return logn<T>(arg0,arg1);
case e_lt : return (arg0 < arg1) ? T(1) : T(0);
case e_lte : return (arg0 <= arg1) ? T(1) : T(0);
case e_eq : return (arg0 == arg1) ? T(1) : T(0);
case e_ne : return (arg0 != arg1) ? T(1) : T(0);
case e_gte : return (arg0 >= arg1) ? T(1) : T(0);
case e_gt : return (arg0 > arg1) ? T(1) : T(0);
case e_and : return ((arg0 != T(0)) && (arg1 != T(0))) ? T(1) : T(0);
case e_nand : return ((arg0 != T(0)) && (arg1 != T(0))) ? T(0) : T(1);
case e_or : return ((arg0 != T(0)) || (arg1 != T(0))) ? T(1) : T(0);
case e_nor : return ((arg0 != T(0)) || (arg1 != T(0))) ? T(0) : T(1);
case e_xor : return arg0 ^ arg1;
case e_xnor : return !(arg0 ^ arg1);
case e_root : return root<T>(arg0,arg1);
case e_equal : return arg0 == arg1;
case e_nequal : return arg0 != arg1;
case e_hypot : return hypot<T>(arg0,arg1);
case e_shr : return arg0 >> arg1;
case e_shl : return arg0 << arg1;
default : exprtk_debug(("numeric::details::process_impl<IntType> - Invalid binary operation.\n"));
return std::numeric_limits<T>::quiet_NaN();
}
}
}
template <typename T>
inline T process(const operator_type operation, const T arg)
{
return exprtk::details::numeric::details::process_impl(operation,arg);
}
template <typename T>
inline T process(const operator_type operation, const T arg0, const T arg1)
{
return exprtk::details::numeric::details::process_impl(operation,arg0,arg1);
}
}
template <typename T>
class expression_node
{
public:
enum node_type
{
e_none , e_null , e_constant , e_unary ,
e_binary , e_binary_ext , e_trinary , e_quaternary ,
e_vararg , e_conditional , e_while , e_repeat ,
e_for , e_switch , e_mswitch , e_return ,
e_retenv , e_variable , e_stringvar , e_stringconst ,
e_stringvarrng , e_cstringvarrng, e_strgenrange , e_strconcat ,
e_stringvarsize, e_strswap , e_stringsize , e_stringvararg ,
e_function , e_vafunction , e_genfunction , e_strfunction ,
e_strcondition , e_strccondition, e_add , e_sub ,
e_mul , e_div , e_mod , e_pow ,
e_lt , e_lte , e_gt , e_gte ,
e_eq , e_ne , e_and , e_nand ,
e_or , e_nor , e_xor , e_xnor ,
e_in , e_like , e_ilike , e_inranges ,
e_ipow , e_ipowinv , e_abs , e_acos ,
e_acosh , e_asin , e_asinh , e_atan ,
e_atanh , e_ceil , e_cos , e_cosh ,
e_exp , e_expm1 , e_floor , e_log ,
e_log10 , e_log2 , e_log1p , e_neg ,
e_pos , e_round , e_sin , e_sinc ,
e_sinh , e_sqrt , e_tan , e_tanh ,
e_cot , e_sec , e_csc , e_r2d ,
e_d2r , e_d2g , e_g2d , e_notl ,
e_sgn , e_erf , e_erfc , e_ncdf ,
e_frac , e_trunc , e_uvouv , e_vov ,
e_cov , e_voc , e_vob , e_bov ,
e_cob , e_boc , e_vovov , e_vovoc ,
e_vocov , e_covov , e_covoc , e_vovovov ,
e_vovovoc , e_vovocov , e_vocovov , e_covovov ,
e_covocov , e_vocovoc , e_covovoc , e_vococov ,
e_sf3ext , e_sf4ext , e_nulleq , e_strass ,
e_vector , e_vecelem , e_rbvecelem , e_rbveccelem ,
e_vecdefass , e_vecvalass , e_vecvecass , e_vecopvalass ,
e_vecopvecass , e_vecfunc , e_vecvecswap , e_vecvecineq ,
e_vecvalineq , e_valvecineq , e_vecvecarith , e_vecvalarith ,
e_valvecarith , e_vecunaryop , e_break , e_continue ,
e_swap
};
typedef T value_type;
typedef expression_node<T>* expression_ptr;
virtual ~expression_node()
{}
inline virtual T value() const
{
return std::numeric_limits<T>::quiet_NaN();
}
inline virtual expression_node<T>* branch(const std::size_t& index = 0) const
{
return reinterpret_cast<expression_ptr>(index * 0);
}
inline virtual node_type type() const
{
return e_none;
}
};
template <typename T>
inline bool is_generally_string_node(const expression_node<T>* node);
inline bool is_true(const double v)
{
return std::not_equal_to<double>()(0.0,v);
}
inline bool is_true(const long double v)
{
return std::not_equal_to<long double>()(0.0L,v);
}
inline bool is_true(const float v)
{
return std::not_equal_to<float>()(0.0f,v);
}
template <typename T>
inline bool is_true(const std::complex<T>& v)
{
return std::not_equal_to<std::complex<T> >()(std::complex<T>(0),v);
}
template <typename T>
inline bool is_true(const expression_node<T>* node)
{
return std::not_equal_to<T>()(T(0),node->value());
}
template <typename T>
inline bool is_false(const expression_node<T>* node)
{
return std::equal_to<T>()(T(0),node->value());
}
template <typename T>
inline bool is_unary_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_unary == node->type());
}
template <typename T>
inline bool is_neg_unary_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_neg == node->type());
}
template <typename T>
inline bool is_binary_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_binary == node->type());
}
template <typename T>
inline bool is_variable_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_variable == node->type());
}
template <typename T>
inline bool is_ivariable_node(const expression_node<T>* node)
{
return node &&
(
details::expression_node<T>::e_variable == node->type() ||
details::expression_node<T>::e_vecelem == node->type() ||
details::expression_node<T>::e_rbvecelem == node->type() ||
details::expression_node<T>::e_rbveccelem == node->type()
);
}
template <typename T>
inline bool is_vector_elem_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_vecelem == node->type());
}
template <typename T>
inline bool is_rebasevector_elem_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_rbvecelem == node->type());
}
template <typename T>
inline bool is_rebasevector_celem_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_rbveccelem == node->type());
}
template <typename T>
inline bool is_vector_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_vector == node->type());
}
template <typename T>
inline bool is_ivector_node(const expression_node<T>* node)
{
if (node)
{
switch (node->type())
{
case details::expression_node<T>::e_vector :
case details::expression_node<T>::e_vecvalass :
case details::expression_node<T>::e_vecvecass :
case details::expression_node<T>::e_vecopvalass :
case details::expression_node<T>::e_vecopvecass :
case details::expression_node<T>::e_vecvecswap :
case details::expression_node<T>::e_vecvecarith :
case details::expression_node<T>::e_vecvalarith :
case details::expression_node<T>::e_valvecarith :
case details::expression_node<T>::e_vecunaryop : return true;
default : return false;
}
}
else
return false;
}
template <typename T>
inline bool is_constant_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_constant == node->type());
}
template <typename T>
inline bool is_null_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_null == node->type());
}
template <typename T>
inline bool is_break_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_break == node->type());
}
template <typename T>
inline bool is_continue_node(const expression_node<T>* node)
{
return node && (details::expression_node<T>::e_continue == node->type());
}
template <typename T>
gitextract_k1kbwdwj/
├── .clang-format
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── cmake.yml
│ └── docs.yml
├── .gitignore
├── .gitmodules
├── 3rdparty/
│ ├── CMakeLists.txt
│ ├── NoesisApp/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── pch.h
│ │ └── register.cpp
│ ├── exprtk/
│ │ ├── CMakeLists.txt
│ │ ├── exprtk.cpp
│ │ ├── exprtk.hpp
│ │ └── license/
│ │ └── license.json
│ └── fastnoise/
│ ├── CMakeLists.txt
│ ├── FastNoise.cpp
│ ├── FastNoise.h
│ ├── LICENSE
│ └── README.md
├── CMakeLists.txt
├── Changelog.md
├── LICENSE
├── README.md
├── cmake/
│ └── modules/
│ ├── FindBugSplat.cmake
│ ├── FindNoesis.cmake
│ ├── FindOpenAL.cmake
│ ├── FindSteam.cmake
│ └── windeployqt.cmake
├── content/
│ ├── CMakeLists.txt
│ ├── JSON/
│ │ ├── config.json
│ │ ├── embarkpresets.json
│ │ ├── menusettings.json
│ │ ├── newgame.json
│ │ └── profs.json
│ ├── ai/
│ │ ├── animal_big.xml
│ │ ├── animal_guard_dog.xml
│ │ ├── animal_hunter.xml
│ │ ├── animal_nighthunter.xml
│ │ ├── animal_small_pasture.xml
│ │ ├── animal_standard.xml
│ │ ├── automaton_mark1.xml
│ │ ├── automaton_mark2.xml
│ │ ├── egg.xml
│ │ ├── gnome_standard.xml
│ │ ├── gnome_trader.xml
│ │ ├── monster_mant_queen.xml
│ │ ├── monster_mant_soldier.xml
│ │ ├── monster_mant_worker.xml
│ │ └── monster_standard.xml
│ ├── db/
│ │ └── ingnomia.db.sql
│ ├── shaders/
│ │ ├── axle_f.glsl
│ │ ├── axle_v.glsl
│ │ ├── selection_f.glsl
│ │ ├── selection_v.glsl
│ │ ├── thoughtbubble_f.glsl
│ │ ├── thoughtbubble_v.glsl
│ │ ├── world_f.glsl
│ │ ├── world_v.glsl
│ │ └── worldupdate_c.glsl
│ └── xaml/
│ ├── Agriculture.xaml
│ ├── CreatureInfo.xaml
│ ├── DebugGui.xaml
│ ├── Fonts/
│ │ └── SIL Open Font License.txt
│ ├── GameGui.xaml
│ ├── IngamePage.xaml
│ ├── InventoryGui.xaml
│ ├── LoadGamePage.xaml
│ ├── Main.xaml
│ ├── MainMenu.xaml
│ ├── MainPage.xaml
│ ├── MilitaryGui.xaml
│ ├── Neighbors.xaml
│ ├── NewGamePage.xaml
│ ├── PopulationWindow.xaml
│ ├── SelectionGui.xaml
│ ├── SettingsPage.xaml
│ ├── StockpileGui.xaml
│ ├── Theme/
│ │ ├── Fonts/
│ │ │ ├── PT Root UI_Bold.otf
│ │ │ └── PT Root UI_Regular.otf
│ │ ├── NoesisTheme.Brushes.DarkAqua.xaml
│ │ ├── NoesisTheme.Brushes.DarkBlue.xaml
│ │ ├── NoesisTheme.Brushes.DarkCrimson.xaml
│ │ ├── NoesisTheme.Brushes.DarkEmerald.xaml
│ │ ├── NoesisTheme.Brushes.DarkGreen.xaml
│ │ ├── NoesisTheme.Brushes.DarkLime.xaml
│ │ ├── NoesisTheme.Brushes.DarkOrange.xaml
│ │ ├── NoesisTheme.Brushes.DarkPurple.xaml
│ │ ├── NoesisTheme.Brushes.DarkRed.xaml
│ │ ├── NoesisTheme.Brushes.LightAqua.xaml
│ │ ├── NoesisTheme.Brushes.LightBlue.xaml
│ │ ├── NoesisTheme.Brushes.LightCrimson.xaml
│ │ ├── NoesisTheme.Brushes.LightEmerald.xaml
│ │ ├── NoesisTheme.Brushes.LightGreen.xaml
│ │ ├── NoesisTheme.Brushes.LightLime.xaml
│ │ ├── NoesisTheme.Brushes.LightOrange.xaml
│ │ ├── NoesisTheme.Brushes.LightPurple.xaml
│ │ ├── NoesisTheme.Brushes.LightRed.xaml
│ │ ├── NoesisTheme.Colors.Dark.xaml
│ │ ├── NoesisTheme.Colors.Light.xaml
│ │ ├── NoesisTheme.DarkAqua.xaml
│ │ ├── NoesisTheme.DarkBlue.xaml
│ │ ├── NoesisTheme.DarkCrimson.xaml
│ │ ├── NoesisTheme.DarkEmerald.xaml
│ │ ├── NoesisTheme.DarkGreen.xaml
│ │ ├── NoesisTheme.DarkLime.xaml
│ │ ├── NoesisTheme.DarkOrange.xaml
│ │ ├── NoesisTheme.DarkPurple.xaml
│ │ ├── NoesisTheme.DarkRed.xaml
│ │ ├── NoesisTheme.Fonts.xaml
│ │ ├── NoesisTheme.LightAqua.xaml
│ │ ├── NoesisTheme.LightBlue.xaml
│ │ ├── NoesisTheme.LightCrimson.xaml
│ │ ├── NoesisTheme.LightEmerald.xaml
│ │ ├── NoesisTheme.LightGreen.xaml
│ │ ├── NoesisTheme.LightLime.xaml
│ │ ├── NoesisTheme.LightOrange.xaml
│ │ ├── NoesisTheme.LightPurple.xaml
│ │ ├── NoesisTheme.LightRed.xaml
│ │ └── NoesisTheme.Styles.xaml
│ ├── TileInfo.xaml
│ ├── WaitPage.xaml
│ ├── WorkshopGui.xaml
│ ├── localization/
│ │ ├── _.xaml
│ │ ├── en_US.xaml
│ │ ├── fr_FR.xaml
│ │ └── pt_BR.xaml
│ └── styles/
│ ├── colors.xaml
│ └── mainmenu/
│ ├── pageswap.xaml
│ └── styles.xaml
├── devmessages.txt
├── docs/
│ ├── Pipfile
│ ├── generate.py
│ └── lib/
│ ├── __init__.py
│ ├── db.py
│ ├── material.py
│ ├── render.py
│ ├── sprites/
│ │ ├── __init__.py
│ │ ├── layout.py
│ │ ├── render.py
│ │ └── sprite.py
│ ├── store.py
│ ├── themes/
│ │ ├── __init__.py
│ │ └── default/
│ │ ├── __init__.py
│ │ ├── assets/
│ │ │ ├── doc.js
│ │ │ └── style.css
│ │ ├── sprites.py
│ │ ├── templates/
│ │ │ ├── base.html.j2
│ │ │ ├── constructions.html.j2
│ │ │ ├── food.html.j2
│ │ │ ├── index.html.j2
│ │ │ ├── item.html.j2
│ │ │ ├── items.html.j2
│ │ │ ├── macros.html.j2
│ │ │ ├── navtable.html.j2
│ │ │ ├── plants.html.j2
│ │ │ ├── sprites.css.j2
│ │ │ ├── tints.svg.j2
│ │ │ ├── workshop.html.j2
│ │ │ └── workshops.html.j2
│ │ └── theme.py
│ └── util.py
├── gui/
│ ├── SampleData/
│ │ ├── GameModelSampleData.xaml
│ │ ├── StockpileModelSampleData.xaml
│ │ └── ViewModelSampleData.xaml
│ ├── Src/
│ │ ├── App.config
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ └── stubs.cs
│ ├── app.config
│ └── gui.csproj
├── keybindings.json
├── resources/
│ └── Plants.docx
├── src/
│ ├── CMakeLists.txt
│ ├── base/
│ │ ├── PathFinderThread.cpp
│ │ ├── PathFinderThread.h
│ │ ├── behaviortree/
│ │ │ ├── bt_factory.cpp
│ │ │ ├── bt_factory.h
│ │ │ ├── bt_node.cpp
│ │ │ ├── bt_node.h
│ │ │ ├── bt_nodeaction.cpp
│ │ │ ├── bt_nodeaction.h
│ │ │ ├── bt_nodebbprecondition.cpp
│ │ │ ├── bt_nodebbprecondition.h
│ │ │ ├── bt_nodeconditional.cpp
│ │ │ ├── bt_nodeconditional.h
│ │ │ ├── bt_nodefallback.cpp
│ │ │ ├── bt_nodefallback.h
│ │ │ ├── bt_nodefallbackstar.cpp
│ │ │ ├── bt_nodefallbackstar.h
│ │ │ ├── bt_nodeforcefailure.cpp
│ │ │ ├── bt_nodeforcefailure.h
│ │ │ ├── bt_nodeforcesuccess.cpp
│ │ │ ├── bt_nodeforcesuccess.h
│ │ │ ├── bt_nodeinverter.cpp
│ │ │ ├── bt_nodeinverter.h
│ │ │ ├── bt_noderepeat.cpp
│ │ │ ├── bt_noderepeat.h
│ │ │ ├── bt_noderepeatuntilsuccess.cpp
│ │ │ ├── bt_noderepeatuntilsuccess.h
│ │ │ ├── bt_nodesequence.cpp
│ │ │ ├── bt_nodesequence.h
│ │ │ ├── bt_nodesequencestar.cpp
│ │ │ ├── bt_nodesequencestar.h
│ │ │ └── bt_tree.h
│ │ ├── config.cpp
│ │ ├── config.h
│ │ ├── counter.h
│ │ ├── crashhandler.cpp
│ │ ├── crashhandler.h
│ │ ├── db.cpp
│ │ ├── db.h
│ │ ├── dbhelper.cpp
│ │ ├── dbhelper.h
│ │ ├── dbstructs.h
│ │ ├── enums.h
│ │ ├── filter.cpp
│ │ ├── filter.h
│ │ ├── gamestate.cpp
│ │ ├── gamestate.h
│ │ ├── global.cpp
│ │ ├── global.h
│ │ ├── io.cpp
│ │ ├── io.h
│ │ ├── lightmap.cpp
│ │ ├── lightmap.h
│ │ ├── logger.cpp
│ │ ├── logger.h
│ │ ├── octree.cpp
│ │ ├── octree.h
│ │ ├── pathfinder.cpp
│ │ ├── pathfinder.h
│ │ ├── position.h
│ │ ├── priorityqueue.h
│ │ ├── region.cpp
│ │ ├── region.h
│ │ ├── regionmap.cpp
│ │ ├── regionmap.h
│ │ ├── selection.cpp
│ │ ├── selection.h
│ │ ├── tile.h
│ │ ├── util.cpp
│ │ ├── util.h
│ │ └── vptr.h
│ ├── game/
│ │ ├── anatomy.cpp
│ │ ├── anatomy.h
│ │ ├── animal.cpp
│ │ ├── animal.h
│ │ ├── automaton.cpp
│ │ ├── automaton.h
│ │ ├── canwork.cpp
│ │ ├── canwork.h
│ │ ├── creature.cpp
│ │ ├── creature.h
│ │ ├── creatureEquipment.cpp
│ │ ├── creaturefactory.cpp
│ │ ├── creaturefactory.h
│ │ ├── creaturemanager.cpp
│ │ ├── creaturemanager.h
│ │ ├── eventmanager.cpp
│ │ ├── eventmanager.h
│ │ ├── farm.cpp
│ │ ├── farm.h
│ │ ├── farmingmanager.cpp
│ │ ├── farmingmanager.h
│ │ ├── fluidmanager.cpp
│ │ ├── fluidmanager.h
│ │ ├── game.cpp
│ │ ├── game.h
│ │ ├── gamemanager.cpp
│ │ ├── gamemanager.h
│ │ ├── gnome.cpp
│ │ ├── gnome.h
│ │ ├── gnomeactions.cpp
│ │ ├── gnomeconditions.cpp
│ │ ├── gnomefactory.cpp
│ │ ├── gnomefactory.h
│ │ ├── gnomemanager.cpp
│ │ ├── gnomemanager.h
│ │ ├── gnometrader.cpp
│ │ ├── gnometrader.h
│ │ ├── grove.cpp
│ │ ├── grove.h
│ │ ├── inventory.cpp
│ │ ├── inventory.h
│ │ ├── item.cpp
│ │ ├── item.h
│ │ ├── itemhistory.cpp
│ │ ├── itemhistory.h
│ │ ├── job.cpp
│ │ ├── job.h
│ │ ├── jobmanager.cpp
│ │ ├── jobmanager.h
│ │ ├── mechanismmanager.cpp
│ │ ├── mechanismmanager.h
│ │ ├── militarymanager.cpp
│ │ ├── militarymanager.h
│ │ ├── monster.cpp
│ │ ├── monster.h
│ │ ├── neighbormanager.cpp
│ │ ├── neighbormanager.h
│ │ ├── newgamesettings.cpp
│ │ ├── newgamesettings.h
│ │ ├── object.cpp
│ │ ├── object.h
│ │ ├── pasture.cpp
│ │ ├── pasture.h
│ │ ├── plant.cpp
│ │ ├── plant.h
│ │ ├── room.cpp
│ │ ├── room.h
│ │ ├── roommanager.cpp
│ │ ├── roommanager.h
│ │ ├── soundmanager.cpp
│ │ ├── soundmanager.h
│ │ ├── stockpile.cpp
│ │ ├── stockpile.h
│ │ ├── stockpilemanager.cpp
│ │ ├── stockpilemanager.h
│ │ ├── techtree.cpp
│ │ ├── techtree.h
│ │ ├── workshop.cpp
│ │ ├── workshop.h
│ │ ├── workshopmanager.cpp
│ │ ├── workshopmanager.h
│ │ ├── world.cpp
│ │ ├── world.h
│ │ ├── worldconstructions.cpp
│ │ ├── worldgenerator.cpp
│ │ ├── worldgenerator.h
│ │ ├── worldgetters.cpp
│ │ ├── worldobject.cpp
│ │ └── worldobject.h
│ ├── gfx/
│ │ ├── sprite.cpp
│ │ ├── sprite.h
│ │ ├── spritefactory.cpp
│ │ └── spritefactory.h
│ ├── gui/
│ │ ├── aggregatoragri.cpp
│ │ ├── aggregatoragri.h
│ │ ├── aggregatorcreatureinfo.cpp
│ │ ├── aggregatorcreatureinfo.h
│ │ ├── aggregatordebug.cpp
│ │ ├── aggregatordebug.h
│ │ ├── aggregatorinventory.cpp
│ │ ├── aggregatorinventory.h
│ │ ├── aggregatorloadgame.cpp
│ │ ├── aggregatorloadgame.h
│ │ ├── aggregatormilitary.cpp
│ │ ├── aggregatormilitary.h
│ │ ├── aggregatorneighbors.cpp
│ │ ├── aggregatorneighbors.h
│ │ ├── aggregatorpopulation.cpp
│ │ ├── aggregatorpopulation.h
│ │ ├── aggregatorrenderer.cpp
│ │ ├── aggregatorrenderer.h
│ │ ├── aggregatorselection.cpp
│ │ ├── aggregatorselection.h
│ │ ├── aggregatorsettings.cpp
│ │ ├── aggregatorsettings.h
│ │ ├── aggregatorsound.cpp
│ │ ├── aggregatorsound.h
│ │ ├── aggregatorstockpile.cpp
│ │ ├── aggregatorstockpile.h
│ │ ├── aggregatortileinfo.cpp
│ │ ├── aggregatortileinfo.h
│ │ ├── aggregatorworkshop.cpp
│ │ ├── aggregatorworkshop.h
│ │ ├── eventconnector.cpp
│ │ ├── eventconnector.h
│ │ ├── keybindings.cpp
│ │ ├── keybindings.h
│ │ ├── license.h.in
│ │ ├── mainwindow.cpp
│ │ ├── mainwindow.h
│ │ ├── mainwindowrenderer.cpp
│ │ ├── mainwindowrenderer.h
│ │ ├── openalwrapper.cpp
│ │ ├── openalwrapper.h
│ │ ├── strings.cpp
│ │ ├── strings.h
│ │ └── xaml/
│ │ ├── GameGui.xaml.cpp
│ │ ├── GameGui.xaml.h
│ │ ├── GameModel.cpp
│ │ ├── GameModel.h
│ │ ├── IngamePage.xaml.cpp
│ │ ├── IngamePage.xaml.h
│ │ ├── LoadGameModel.cpp
│ │ ├── LoadGameModel.h
│ │ ├── LoadGamePage.xaml.cpp
│ │ ├── LoadGamePage.xaml.h
│ │ ├── Main.xaml.cpp
│ │ ├── Main.xaml.h
│ │ ├── MainMenu.xaml.cpp
│ │ ├── MainMenu.xaml.h
│ │ ├── MainPage.xaml.cpp
│ │ ├── MainPage.xaml.h
│ │ ├── NewGameModel.cpp
│ │ ├── NewGameModel.h
│ │ ├── NewGamePage.xaml.cpp
│ │ ├── NewGamePage.xaml.h
│ │ ├── Population.xaml.cpp
│ │ ├── Population.xaml.h
│ │ ├── PopulationModel.cpp
│ │ ├── PopulationModel.h
│ │ ├── ProxyGameView.cpp
│ │ ├── ProxyGameView.h
│ │ ├── ProxyMainView.cpp
│ │ ├── ProxyMainView.h
│ │ ├── ProxyTileInfo.cpp
│ │ ├── ProxyTileInfo.h
│ │ ├── SettingsModel.cpp
│ │ ├── SettingsModel.h
│ │ ├── SettingsPage.xaml.cpp
│ │ ├── SettingsPage.xaml.h
│ │ ├── StockpileModel.cpp
│ │ ├── StockpileModel.h
│ │ ├── StockpileProxy.cpp
│ │ ├── StockpileProxy.h
│ │ ├── TileInfo.xaml.cpp
│ │ ├── TileInfo.xaml.h
│ │ ├── TileInfoModel.cpp
│ │ ├── TileInfoModel.h
│ │ ├── ViewModel.cpp
│ │ ├── ViewModel.h
│ │ ├── WaitPage.xaml.cpp
│ │ ├── WaitPage.xaml.h
│ │ ├── agriculture.xaml.cpp
│ │ ├── agriculture.xaml.h
│ │ ├── agriculturemodel.cpp
│ │ ├── agriculturemodel.h
│ │ ├── agricultureproxy.cpp
│ │ ├── agricultureproxy.h
│ │ ├── converters.cpp
│ │ ├── converters.h
│ │ ├── creatureinfo.xaml.cpp
│ │ ├── creatureinfo.xaml.h
│ │ ├── creatureinfomodel.cpp
│ │ ├── creatureinfomodel.h
│ │ ├── creatureinfoproxy.cpp
│ │ ├── creatureinfoproxy.h
│ │ ├── debug.xaml.cpp
│ │ ├── debug.xaml.h
│ │ ├── debugmodel.cpp
│ │ ├── debugmodel.h
│ │ ├── debugproxy.cpp
│ │ ├── debugproxy.h
│ │ ├── inventory.xaml.cpp
│ │ ├── inventory.xaml.h
│ │ ├── inventorymodel.cpp
│ │ ├── inventorymodel.h
│ │ ├── inventoryproxy.cpp
│ │ ├── inventoryproxy.h
│ │ ├── loadgameproxy.cpp
│ │ ├── loadgameproxy.h
│ │ ├── military.xaml.cpp
│ │ ├── military.xaml.h
│ │ ├── militarymodel.cpp
│ │ ├── militarymodel.h
│ │ ├── militaryproxy.cpp
│ │ ├── militaryproxy.h
│ │ ├── neighbors.xaml.cpp
│ │ ├── neighbors.xaml.h
│ │ ├── neighborsmodel.cpp
│ │ ├── neighborsmodel.h
│ │ ├── neighborsproxy.cpp
│ │ ├── neighborsproxy.h
│ │ ├── populationproxy.cpp
│ │ ├── populationproxy.h
│ │ ├── selection.xaml.cpp
│ │ ├── selection.xaml.h
│ │ ├── selectionmodel.cpp
│ │ ├── selectionmodel.h
│ │ ├── selectionproxy.cpp
│ │ ├── selectionproxy.h
│ │ ├── settingsproxy.cpp
│ │ ├── settingsproxy.h
│ │ ├── stockpilegui.xaml.cpp
│ │ ├── stockpilegui.xaml.h
│ │ ├── workshopgui.xaml.cpp
│ │ ├── workshopgui.xaml.h
│ │ ├── workshopmodel.cpp
│ │ ├── workshopmodel.h
│ │ ├── workshopproxy.cpp
│ │ └── workshopproxy.h
│ ├── main.cpp
│ ├── pch.h
│ └── version.h.in
└── windows/
├── Ingnomia.manifest
├── Ingnomia.rc
└── resource.h
Showing preview only (867K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4061 symbols across 254 files)
FILE: 3rdparty/NoesisApp/register.cpp
function NsRegisterReflection_NoesisApp (line 24) | void NsRegisterReflection_NoesisApp()
function NsInitPackages_NoesisApp (line 39) | void NsInitPackages_NoesisApp()
function NsShutdownPackages_NoesisApp (line 54) | void NsShutdownPackages_NoesisApp()
FILE: 3rdparty/exprtk/exprtk.hpp
type exprtk (line 59) | namespace exprtk
type details (line 84) | namespace details
function is_whitespace (line 89) | inline bool is_whitespace(const char_t c)
function is_operator_char (line 97) | inline bool is_operator_char(const char_t c)
function is_letter (line 112) | inline bool is_letter(const char_t c)
function is_digit (line 118) | inline bool is_digit(const char_t c)
function is_letter_or_digit (line 123) | inline bool is_letter_or_digit(const char_t c)
function is_left_bracket (line 128) | inline bool is_left_bracket(const char_t c)
function is_right_bracket (line 133) | inline bool is_right_bracket(const char_t c)
function is_bracket (line 138) | inline bool is_bracket(const char_t c)
function is_sign (line 143) | inline bool is_sign(const char_t c)
function is_invalid (line 148) | inline bool is_invalid(const char_t c)
function case_normalise (line 162) | inline void case_normalise(std::string& s)
function imatch (line 170) | inline bool imatch(const char_t c1, const char_t c2)
function imatch (line 175) | inline bool imatch(const std::string& s1, const std::string& s2)
type ilesscompare (line 193) | struct ilesscompare
function case_normalise (line 215) | inline void case_normalise(std::string&)
function imatch (line 218) | inline bool imatch(const char_t c1, const char_t c2)
function imatch (line 223) | inline bool imatch(const std::string& s1, const std::string& s2)
type ilesscompare (line 228) | struct ilesscompare
function is_valid_sf_symbol (line 237) | inline bool is_valid_sf_symbol(const std::string& symbol)
function char_t (line 247) | inline const char_t& front(const std::string& s)
function char_t (line 252) | inline const char_t& back(const std::string& s)
function to_str (line 257) | inline std::string to_str(int i)
function to_str (line 286) | inline std::string to_str(std::size_t i)
function is_hex_digit (line 291) | inline bool is_hex_digit(const std::string::value_type digit)
function uchar_t (line 298) | inline uchar_t hex_to_bin(uchar_t h)
function parse_hex (line 307) | inline void parse_hex(Iterator& itr, Iterator end, std::string::valu...
function cleanup_escapes (line 331) | inline void cleanup_escapes(std::string& s)
class build_string (line 377) | class build_string
method build_string (line 381) | build_string(const std::size_t& initial_size = 64)
method build_string (line 386) | inline build_string& operator << (const std::string& s)
method build_string (line 392) | inline build_string& operator << (const char_t* s)
method as_string (line 403) | inline std::string as_string() const
function is_reserved_word (line 496) | inline bool is_reserved_word(const std::string& symbol)
function is_reserved_symbol (line 509) | inline bool is_reserved_symbol(const std::string& symbol)
function is_base_function (line 522) | inline bool is_base_function(const std::string& function_name)
function is_control_struct (line 535) | inline bool is_control_struct(const std::string& cntrl_strct)
function is_logic_opr (line 548) | inline bool is_logic_opr(const std::string& lgc_opr)
type cs_match (line 561) | struct cs_match
method cmp (line 563) | static inline bool cmp(const char_t c0, const char_t c1)
type cis_match (line 569) | struct cis_match
method cmp (line 571) | static inline bool cmp(const char_t c0, const char_t c1)
function match_impl (line 578) | inline bool match_impl(const Iterator pattern_begin,
function wc_match (line 636) | inline bool wc_match(const std::string& wild_card,
function wc_imatch (line 647) | inline bool wc_imatch(const std::string& wild_card,
function sequence_match (line 658) | inline bool sequence_match(const std::string& pattern,
type numeric (line 738) | namespace numeric
type constant (line 740) | namespace constant
type details (line 754) | namespace details
type unknown_type_tag (line 756) | struct unknown_type_tag { unknown_type_tag() {} }
method unknown_type_tag (line 756) | unknown_type_tag() {}
type real_type_tag (line 757) | struct real_type_tag { real_type_tag () {} }
method real_type_tag (line 757) | real_type_tag () {}
type complex_type_tag (line 758) | struct complex_type_tag { complex_type_tag() {} }
method complex_type_tag (line 758) | complex_type_tag() {}
type int_type_tag (line 759) | struct int_type_tag { int_type_tag () {} }
method int_type_tag (line 759) | int_type_tag () {}
type number_type (line 762) | struct number_type
method number_type (line 765) | number_type() {}
type epsilon_type (line 799) | struct epsilon_type
method T (line 801) | static inline T value()
type epsilon_type <float> (line 809) | struct epsilon_type <float>
method value (line 811) | static inline float value()
type epsilon_type <long double> (line 819) | struct epsilon_type <long double>
method value (line 821) | static inline long double value()
function is_nan_impl (line 829) | inline bool is_nan_impl(const T v, real_type_tag)
function to_int32_impl (line 835) | inline int to_int32_impl(const T v, real_type_tag)
function to_int64_impl (line 841) | inline long long int to_int64_impl(const T v, real_type_tag)
function is_true_impl (line 847) | inline bool is_true_impl(const T v)
function is_false_impl (line 853) | inline bool is_false_impl(const T v)
function T (line 859) | inline T abs_impl(const T v, real_type_tag)
function T (line 865) | inline T min_impl(const T v0, const T v1, real_type_tag)
function T (line 871) | inline T max_impl(const T v0, const T v1, real_type_tag)
function T (line 877) | inline T equal_impl(const T v0, const T v1, real_type_tag)
function equal_impl (line 883) | inline float equal_impl(const float v0, const float v1, real_typ...
function T (line 890) | inline T equal_impl(const T v0, const T v1, int_type_tag)
function T (line 896) | inline T expm1_impl(const T v, real_type_tag)
function T (line 906) | inline T expm1_impl(const T v, int_type_tag)
function T (line 912) | inline T nequal_impl(const T v0, const T v1, real_type_tag)
function nequal_impl (line 919) | inline float nequal_impl(const float v0, const float v1, real_ty...
function T (line 927) | inline T nequal_impl(const T v0, const T v1, int_type_tag)
function T (line 933) | inline T modulus_impl(const T v0, const T v1, real_type_tag)
function T (line 939) | inline T modulus_impl(const T v0, const T v1, int_type_tag)
function T (line 945) | inline T pow_impl(const T v0, const T v1, real_type_tag)
function T (line 951) | inline T pow_impl(const T v0, const T v1, int_type_tag)
function T (line 957) | inline T logn_impl(const T v0, const T v1, real_type_tag)
function T (line 963) | inline T logn_impl(const T v0, const T v1, int_type_tag)
function T (line 969) | inline T log1p_impl(const T v, real_type_tag)
function T (line 985) | inline T log1p_impl(const T v, int_type_tag)
function T (line 996) | inline T root_impl(const T v0, const T v1, real_type_tag)
function T (line 1010) | inline T root_impl(const T v0, const T v1, int_type_tag)
function T (line 1016) | inline T round_impl(const T v, real_type_tag)
function T (line 1022) | inline T roundn_impl(const T v0, const T v1, real_type_tag)
function T (line 1034) | inline T roundn_impl(const T v0, const T, int_type_tag)
function T (line 1040) | inline T hypot_impl(const T v0, const T v1, real_type_tag)
function T (line 1046) | inline T hypot_impl(const T v0, const T v1, int_type_tag)
function T (line 1052) | inline T atan2_impl(const T v0, const T v1, real_type_tag)
function T (line 1058) | inline T atan2_impl(const T, const T, int_type_tag)
function T (line 1064) | inline T shr_impl(const T v0, const T v1, real_type_tag)
function T (line 1070) | inline T shr_impl(const T v0, const T v1, int_type_tag)
function T (line 1076) | inline T shl_impl(const T v0, const T v1, real_type_tag)
function T (line 1082) | inline T shl_impl(const T v0, const T v1, int_type_tag)
function T (line 1088) | inline T sgn_impl(const T v, real_type_tag)
function T (line 1096) | inline T sgn_impl(const T v, int_type_tag)
function T (line 1104) | inline T and_impl(const T v0, const T v1, real_type_tag)
function T (line 1110) | inline T and_impl(const T v0, const T v1, int_type_tag)
function T (line 1116) | inline T nand_impl(const T v0, const T v1, real_type_tag)
function T (line 1122) | inline T nand_impl(const T v0, const T v1, int_type_tag)
function T (line 1128) | inline T or_impl(const T v0, const T v1, real_type_tag)
function T (line 1134) | inline T or_impl(const T v0, const T v1, int_type_tag)
function T (line 1140) | inline T nor_impl(const T v0, const T v1, real_type_tag)
function T (line 1146) | inline T nor_impl(const T v0, const T v1, int_type_tag)
function T (line 1152) | inline T xor_impl(const T v0, const T v1, real_type_tag)
function T (line 1158) | inline T xor_impl(const T v0, const T v1, int_type_tag)
function T (line 1164) | inline T xnor_impl(const T v0, const T v1, real_type_tag)
function T (line 1176) | inline T xnor_impl(const T v0, const T v1, int_type_tag)
function T (line 1198) | inline T erf_impl(T v, real_type_tag)
function T (line 1226) | inline T erf_impl(T v, int_type_tag)
function T (line 1242) | inline T erfc_impl(T v, real_type_tag)
function T (line 1252) | inline T erfc_impl(T v, int_type_tag)
function T (line 1258) | inline T ncdf_impl(T v, real_type_tag)
function T (line 1267) | inline T ncdf_impl(T v, int_type_tag)
function T (line 1273) | inline T sinc_impl(T v, real_type_tag)
function T (line 1282) | inline T sinc_impl(T v, int_type_tag)
function T (line 1287) | inline T acos_impl(const T v, real_type_tag) { return std::acos...
function T (line 1288) | inline T acosh_impl(const T v, real_type_tag) { return std::log(...
function T (line 1289) | inline T asin_impl(const T v, real_type_tag) { return std::asin...
function T (line 1290) | inline T asinh_impl(const T v, real_type_tag) { return std::log(...
function T (line 1291) | inline T atan_impl(const T v, real_type_tag) { return std::atan...
function T (line 1292) | inline T atanh_impl(const T v, real_type_tag) { return (std::log...
function T (line 1293) | inline T ceil_impl(const T v, real_type_tag) { return std::ceil...
function T (line 1294) | inline T cos_impl(const T v, real_type_tag) { return std::cos ...
function T (line 1295) | inline T cosh_impl(const T v, real_type_tag) { return std::cosh...
function T (line 1296) | inline T exp_impl(const T v, real_type_tag) { return std::exp ...
function T (line 1297) | inline T floor_impl(const T v, real_type_tag) { return std::floo...
function T (line 1298) | inline T log_impl(const T v, real_type_tag) { return std::log ...
function T (line 1299) | inline T log10_impl(const T v, real_type_tag) { return std::log1...
function T (line 1300) | inline T log2_impl(const T v, real_type_tag) { return std::log(...
function T (line 1301) | inline T neg_impl(const T v, real_type_tag) { return -v; ...
function T (line 1302) | inline T pos_impl(const T v, real_type_tag) { return +v; ...
function T (line 1303) | inline T sin_impl(const T v, real_type_tag) { return std::sin ...
function T (line 1304) | inline T sinh_impl(const T v, real_type_tag) { return std::sinh...
function T (line 1305) | inline T sqrt_impl(const T v, real_type_tag) { return std::sqrt...
function T (line 1306) | inline T tan_impl(const T v, real_type_tag) { return std::tan ...
function T (line 1307) | inline T tanh_impl(const T v, real_type_tag) { return std::tanh...
function T (line 1308) | inline T cot_impl(const T v, real_type_tag) { return T(1) / st...
function T (line 1309) | inline T sec_impl(const T v, real_type_tag) { return T(1) / st...
function T (line 1310) | inline T csc_impl(const T v, real_type_tag) { return T(1) / st...
function T (line 1311) | inline T r2d_impl(const T v, real_type_tag) { return (v * T(nu...
function T (line 1312) | inline T d2r_impl(const T v, real_type_tag) { return (v * T(nu...
function T (line 1313) | inline T d2g_impl(const T v, real_type_tag) { return (v * T(20...
function T (line 1314) | inline T g2d_impl(const T v, real_type_tag) { return (v * T(9....
function T (line 1315) | inline T notl_impl(const T v, real_type_tag) { return (std::not...
function T (line 1316) | inline T frac_impl(const T v, real_type_tag) { return (v - stat...
function T (line 1317) | inline T trunc_impl(const T v, real_type_tag) { return T(static_...
function T (line 1319) | inline T const_pi_impl(real_type_tag) { return numeric::constant...
function T (line 1320) | inline T const_e_impl (real_type_tag) { return numeric::constant...
function T (line 1322) | inline T abs_impl(const T v, int_type_tag) { return ((v >= T(0...
function T (line 1323) | inline T exp_impl(const T v, int_type_tag) { return std::exp ...
function T (line 1324) | inline T log_impl(const T v, int_type_tag) { return std::log ...
function T (line 1325) | inline T log10_impl(const T v, int_type_tag) { return std::log10...
function T (line 1326) | inline T log2_impl(const T v, int_type_tag) { return std::log(v...
function T (line 1327) | inline T neg_impl(const T v, int_type_tag) { return -v; ...
function T (line 1328) | inline T pos_impl(const T v, int_type_tag) { return +v; ...
function T (line 1329) | inline T ceil_impl(const T v, int_type_tag) { return v; ...
function T (line 1330) | inline T floor_impl(const T v, int_type_tag) { return v; ...
function T (line 1331) | inline T round_impl(const T v, int_type_tag) { return v; ...
function T (line 1332) | inline T notl_impl(const T v, int_type_tag) { return !v; ...
function T (line 1333) | inline T sqrt_impl(const T v, int_type_tag) { return std::sqrt ...
function T (line 1334) | inline T frac_impl(const T , int_type_tag) { return T(0); ...
function T (line 1335) | inline T trunc_impl(const T v, int_type_tag) { return v; ...
function T (line 1336) | inline T acos_impl(const T , int_type_tag) { return std::numer...
function T (line 1337) | inline T acosh_impl(const T , int_type_tag) { return std::numer...
function T (line 1338) | inline T asin_impl(const T , int_type_tag) { return std::numer...
function T (line 1339) | inline T asinh_impl(const T , int_type_tag) { return std::numer...
function T (line 1340) | inline T atan_impl(const T , int_type_tag) { return std::numer...
function T (line 1341) | inline T atanh_impl(const T , int_type_tag) { return std::numer...
function T (line 1342) | inline T cos_impl(const T , int_type_tag) { return std::numer...
function T (line 1343) | inline T cosh_impl(const T , int_type_tag) { return std::numer...
function T (line 1344) | inline T sin_impl(const T , int_type_tag) { return std::numer...
function T (line 1345) | inline T sinh_impl(const T , int_type_tag) { return std::numer...
function T (line 1346) | inline T tan_impl(const T , int_type_tag) { return std::numer...
function T (line 1347) | inline T tanh_impl(const T , int_type_tag) { return std::numer...
function T (line 1348) | inline T cot_impl(const T , int_type_tag) { return std::numer...
function T (line 1349) | inline T sec_impl(const T , int_type_tag) { return std::numer...
function T (line 1350) | inline T csc_impl(const T , int_type_tag) { return std::numer...
function is_integer_impl (line 1353) | inline bool is_integer_impl(const T& v, real_type_tag)
function is_integer_impl (line 1359) | inline bool is_integer_impl(const T&, int_type_tag)
type numeric_info (line 1366) | struct numeric_info { enum { length = 0, size = 32, bound_length =...
type numeric_info<int> (line 1368) | struct numeric_info<int> { enum { length = 10, size = 16, ...
type numeric_info<float> (line 1369) | struct numeric_info<float> { enum { min_exp = -38, max_exp ...
type numeric_info<double> (line 1370) | struct numeric_info<double> { enum { min_exp = -308, max_exp ...
type numeric_info<long double> (line 1371) | struct numeric_info<long double> { enum { min_exp = -308, max_exp ...
function to_int32 (line 1374) | inline int to_int32(const T v)
function to_int64 (line 1381) | inline long long int to_int64(const T v)
function is_nan (line 1388) | inline bool is_nan(const T v)
function T (line 1395) | inline T min(const T v0, const T v1)
function T (line 1402) | inline T max(const T v0, const T v1)
function T (line 1409) | inline T equal(const T v0, const T v1)
function T (line 1416) | inline T nequal(const T v0, const T v1)
function T (line 1423) | inline T modulus(const T v0, const T v1)
function T (line 1430) | inline T pow(const T v0, const T v1)
function T (line 1437) | inline T logn(const T v0, const T v1)
function T (line 1444) | inline T root(const T v0, const T v1)
function T (line 1451) | inline T roundn(const T v0, const T v1)
function T (line 1458) | inline T hypot(const T v0, const T v1)
function T (line 1465) | inline T atan2(const T v0, const T v1)
function T (line 1472) | inline T shr(const T v0, const T v1)
function T (line 1479) | inline T shl(const T v0, const T v1)
function T (line 1486) | inline T and_opr(const T v0, const T v1)
function T (line 1493) | inline T nand_opr(const T v0, const T v1)
function T (line 1500) | inline T or_opr(const T v0, const T v1)
function T (line 1507) | inline T nor_opr(const T v0, const T v1)
function T (line 1514) | inline T xor_opr(const T v0, const T v1)
function T (line 1521) | inline T xnor_opr(const T v0, const T v1)
function is_integer (line 1528) | inline bool is_integer(const T v)
type fast_exp (line 1535) | struct fast_exp
method T (line 1537) | static inline T result(T v)
type fast_exp<T,10> (line 1558) | struct fast_exp<T,10> { static inline T result(T v) { T v_5 = fast...
method T (line 1558) | static inline T result(T v) { T v_5 = fast_exp<T,5>::result(v); ...
type fast_exp<T, 9> (line 1559) | struct fast_exp<T, 9> { static inline T result(T v) { return fast_...
method T (line 1559) | static inline T result(T v) { return fast_exp<T,8>::result(v) * ...
type fast_exp<T, 8> (line 1560) | struct fast_exp<T, 8> { static inline T result(T v) { T v_4 = fast...
method T (line 1560) | static inline T result(T v) { T v_4 = fast_exp<T,4>::result(v); ...
type fast_exp<T, 7> (line 1561) | struct fast_exp<T, 7> { static inline T result(T v) { return fast_...
method T (line 1561) | static inline T result(T v) { return fast_exp<T,6>::result(v) * ...
type fast_exp<T, 6> (line 1562) | struct fast_exp<T, 6> { static inline T result(T v) { T v_3 = fast...
method T (line 1562) | static inline T result(T v) { T v_3 = fast_exp<T,3>::result(v); ...
type fast_exp<T, 5> (line 1563) | struct fast_exp<T, 5> { static inline T result(T v) { return fast_...
method T (line 1563) | static inline T result(T v) { return fast_exp<T,4>::result(v) * ...
type fast_exp<T, 4> (line 1564) | struct fast_exp<T, 4> { static inline T result(T v) { T v_2 = v * ...
method T (line 1564) | static inline T result(T v) { T v_2 = v * v; return v_2 * v_2; }
type fast_exp<T, 3> (line 1565) | struct fast_exp<T, 3> { static inline T result(T v) { return v * v...
method T (line 1565) | static inline T result(T v) { return v * v * v; }
type fast_exp<T, 2> (line 1566) | struct fast_exp<T, 2> { static inline T result(T v) { return v * v...
method T (line 1566) | static inline T result(T v) { return v * v; }
type fast_exp<T, 1> (line 1567) | struct fast_exp<T, 1> { static inline T result(T v) { return v; ...
method T (line 1567) | static inline T result(T v) { return v; }
type fast_exp<T, 0> (line 1568) | struct fast_exp<T, 0> { static inline T result(T ) { return T(1);...
method T (line 1568) | static inline T result(T ) { return T(1); }
function T (line 1622) | inline T compute_pow10(T d, const int exponent)
function string_to_type_converter_impl_ref (line 1684) | inline bool string_to_type_converter_impl_ref(Iterator& itr, const I...
function parse_nan (line 1757) | static inline bool parse_nan(Iterator& itr, const Iterator end, T& t)
function parse_inf (line 1790) | static inline bool parse_inf(Iterator& itr, const Iterator end, T& t, ...
function string_to_real (line 1824) | inline bool string_to_real(Iterator& itr_external, const Iterator end,...
function string_to_real (line 1985) | inline bool string_to_real(const std::string& s, T& t)
type functor_t (line 1996) | struct functor_t
class timer (line 36322) | class timer
method timer (line 36327) | timer()
method start (line 36333) | inline void start()
method stop (line 36339) | inline void stop()
method time (line 36345) | inline double time() const
method timer (line 36352) | timer()
method start (line 36361) | inline void start()
method stop (line 36367) | inline void stop()
method usec_time (line 36373) | inline unsigned long long int usec_time() const
method time (line 36389) | inline double time() const
method in_use (line 36396) | inline bool in_use() const
type timeval (line 36410) | struct timeval
type timeval (line 36411) | struct timeval
type rtl (line 36420) | namespace rtl { namespace io { namespace details
type io (line 36420) | namespace io { namespace details
type details (line 36420) | namespace details
function print_type (line 36423) | inline void print_type(const std::string& fmt,
type print_impl (line 36431) | struct print_impl
method process (line 36440) | static void process(const std::string& scalar_format, paramete...
method print (line 36462) | static inline void print(const std::string& scalar_format, con...
method print (line 36467) | static inline void print(const std::string& scalar_format, con...
method print (line 36478) | static inline void print(const string_t& s)
type print (line 36487) | struct print : public exprtk::igeneric_function<T>
method print (line 36493) | print(const std::string& scalar_format = "%10.5f")
method T (line 36499) | inline T operator() (parameter_list_t parameters)
type println (line 36509) | struct println : public exprtk::igeneric_function<T>
method println (line 36515) | println(const std::string& scalar_format = "%10.5f")
method T (line 36521) | inline T operator() (parameter_list_t parameters)
type package (line 36532) | struct package
method register_package (line 36537) | bool register_package(exprtk::symbol_table<T>& symtab)
type file (line 36565) | namespace file { namespace details
type details (line 36565) | namespace details
type file_mode (line 36567) | enum file_mode
type file_descriptor (line 36575) | struct file_descriptor
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function file_descriptor (line 36760) | file_descriptor* make_handle(T v)
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function perform_check (line 36771) | void perform_check()
class open (line 36789) | class open : public exprtk::igeneric_function<T>
method open (line 36800) | open()
method T (line 36804) | inline T operator() (const std::size_t& ps_index, parameter_li...
type close (line 36841) | struct close : public exprtk::ifunction<T>
method close (line 36845) | close()
method T (line 36849) | inline T operator() (const T& v)
class write (line 36863) | class write : public exprtk::igeneric_function<T>
method write (line 36876) | write()
method T (line 36880) | inline T operator() (const std::size_t& ps_index, parameter_li...
class read (line 36920) | class read : public exprtk::igeneric_function<T>
method read (line 36933) | read()
method T (line 36937) | inline T operator() (const std::size_t& ps_index, parameter_li...
class getline (line 36977) | class getline : public exprtk::igeneric_function<T>
method getline (line 36989) | getline()
method T (line 36993) | inline T operator() (std::string& result,
type eof (line 37002) | struct eof : public exprtk::ifunction<T>
method eof (line 37006) | eof()
method T (line 37010) | inline T operator() (const T& v)
type package (line 37019) | struct package
method register_package (line 37028) | bool register_package(exprtk::symbol_table<T>& symtab)
type io (line 36565) | namespace io { namespace file { namespace details
type details (line 36420) | namespace details
function print_type (line 36423) | inline void print_type(const std::string& fmt,
type print_impl (line 36431) | struct print_impl
method process (line 36440) | static void process(const std::string& scalar_format, paramete...
method print (line 36462) | static inline void print(const std::string& scalar_format, con...
method print (line 36467) | static inline void print(const std::string& scalar_format, con...
method print (line 36478) | static inline void print(const string_t& s)
type print (line 36487) | struct print : public exprtk::igeneric_function<T>
method print (line 36493) | print(const std::string& scalar_format = "%10.5f")
method T (line 36499) | inline T operator() (parameter_list_t parameters)
type println (line 36509) | struct println : public exprtk::igeneric_function<T>
method println (line 36515) | println(const std::string& scalar_format = "%10.5f")
method T (line 36521) | inline T operator() (parameter_list_t parameters)
type package (line 36532) | struct package
method register_package (line 36537) | bool register_package(exprtk::symbol_table<T>& symtab)
type file (line 36565) | namespace file { namespace details
type details (line 36565) | namespace details
type file_mode (line 36567) | enum file_mode
type file_descriptor (line 36575) | struct file_descriptor
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function file_descriptor (line 36760) | file_descriptor* make_handle(T v)
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function perform_check (line 36771) | void perform_check()
class open (line 36789) | class open : public exprtk::igeneric_function<T>
method open (line 36800) | open()
method T (line 36804) | inline T operator() (const std::size_t& ps_index, parameter_li...
type close (line 36841) | struct close : public exprtk::ifunction<T>
method close (line 36845) | close()
method T (line 36849) | inline T operator() (const T& v)
class write (line 36863) | class write : public exprtk::igeneric_function<T>
method write (line 36876) | write()
method T (line 36880) | inline T operator() (const std::size_t& ps_index, parameter_li...
class read (line 36920) | class read : public exprtk::igeneric_function<T>
method read (line 36933) | read()
method T (line 36937) | inline T operator() (const std::size_t& ps_index, parameter_li...
class getline (line 36977) | class getline : public exprtk::igeneric_function<T>
method getline (line 36989) | getline()
method T (line 36993) | inline T operator() (std::string& result,
type eof (line 37002) | struct eof : public exprtk::ifunction<T>
method eof (line 37006) | eof()
method T (line 37010) | inline T operator() (const T& v)
type package (line 37019) | struct package
method register_package (line 37028) | bool register_package(exprtk::symbol_table<T>& symtab)
type vecops (line 37060) | namespace vecops {
type helper (line 37062) | namespace helper
function invalid_range (line 37065) | inline bool invalid_range(const Vector& v, const std::size_t r0,...
type load_vector_range (line 37078) | struct load_vector_range
method process (line 37086) | static inline bool process(parameter_list_t& parameters,
type details (line 37109) | namespace details
function kahan_sum (line 37112) | inline void kahan_sum(T& sum, T& error, T v)
class all_true (line 37123) | class all_true : public exprtk::igeneric_function<T>
method all_true (line 37134) | all_true()
method T (line 37143) | inline T operator() (const std::size_t& ps_index, parameter_list...
class all_false (line 37169) | class all_false : public exprtk::igeneric_function<T>
method all_false (line 37180) | all_false()
method T (line 37189) | inline T operator() (const std::size_t& ps_index, parameter_list...
class any_true (line 37215) | class any_true : public exprtk::igeneric_function<T>
method any_true (line 37226) | any_true()
method T (line 37235) | inline T operator() (const std::size_t& ps_index, parameter_list...
class any_false (line 37261) | class any_false : public exprtk::igeneric_function<T>
method any_false (line 37272) | any_false()
method T (line 37281) | inline T operator() (const std::size_t& ps_index, parameter_list...
class count (line 37307) | class count : public exprtk::igeneric_function<T>
method count (line 37318) | count()
method T (line 37327) | inline T operator() (const std::size_t& ps_index, parameter_list...
class copy (line 37352) | class copy : public exprtk::igeneric_function<T>
method copy (line 37364) | copy()
method T (line 37373) | inline T operator() (const std::size_t& ps_index, parameter_list...
class rol (line 37402) | class rol : public exprtk::igeneric_function<T>
method rol (line 37414) | rol()
method T (line 37423) | inline T operator() (const std::size_t& ps_index, parameter_list...
class ror (line 37450) | class ror : public exprtk::igeneric_function<T>
method ror (line 37462) | ror()
method T (line 37471) | inline T operator() (const std::size_t& ps_index, parameter_list...
class shift_left (line 37498) | class shift_left : public exprtk::igeneric_function<T>
method shift_left (line 37510) | shift_left()
method T (line 37519) | inline T operator() (const std::size_t& ps_index, parameter_list...
class shift_right (line 37553) | class shift_right : public exprtk::igeneric_function<T>
method shift_right (line 37565) | shift_right()
method T (line 37574) | inline T operator() (const std::size_t& ps_index, parameter_list...
class sort (line 37610) | class sort : public exprtk::igeneric_function<T>
method sort (line 37622) | sort()
method T (line 37633) | inline T operator() (const std::size_t& ps_index, parameter_list...
class nthelement (line 37667) | class nthelement : public exprtk::igeneric_function<T>
method nthelement (line 37679) | nthelement()
method T (line 37688) | inline T operator() (const std::size_t& ps_index, parameter_list...
class iota (line 37709) | class iota : public exprtk::igeneric_function<T>
method iota (line 37721) | iota()
method T (line 37732) | inline T operator() (const std::size_t& ps_index, parameter_list...
class sumk (line 37761) | class sumk : public exprtk::igeneric_function<T>
method sumk (line 37772) | sumk()
method T (line 37781) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpy (line 37804) | class axpy : public exprtk::igeneric_function<T>
method axpy (line 37816) | axpy()
method T (line 37826) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpby (line 37851) | class axpby : public exprtk::igeneric_function<T>
method axpby (line 37863) | axpby()
method T (line 37873) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpyz (line 37899) | class axpyz : public exprtk::igeneric_function<T>
method axpyz (line 37911) | axpyz()
method T (line 37921) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpbyz (line 37949) | class axpbyz : public exprtk::igeneric_function<T>
method axpbyz (line 37961) | axpbyz()
method T (line 37971) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpbz (line 38000) | class axpbz : public exprtk::igeneric_function<T>
method axpbz (line 38012) | axpbz()
method T (line 38022) | inline T operator() (const std::size_t& ps_index, parameter_list...
class dot (line 38048) | class dot : public exprtk::igeneric_function<T>
method dot (line 38060) | dot()
method T (line 38069) | inline T operator() (const std::size_t& ps_index, parameter_list...
class dotk (line 38094) | class dotk : public exprtk::igeneric_function<T>
method dotk (line 38106) | dotk()
method T (line 38115) | inline T operator() (const std::size_t& ps_index, parameter_list...
type package (line 38141) | struct package
method register_package (line 38165) | bool register_package(exprtk::symbol_table<T>& symtab)
type rtl (line 36565) | namespace rtl { namespace io { namespace file { namespace details
type io (line 36420) | namespace io { namespace details
type details (line 36420) | namespace details
function print_type (line 36423) | inline void print_type(const std::string& fmt,
type print_impl (line 36431) | struct print_impl
method process (line 36440) | static void process(const std::string& scalar_format, paramete...
method print (line 36462) | static inline void print(const std::string& scalar_format, con...
method print (line 36467) | static inline void print(const std::string& scalar_format, con...
method print (line 36478) | static inline void print(const string_t& s)
type print (line 36487) | struct print : public exprtk::igeneric_function<T>
method print (line 36493) | print(const std::string& scalar_format = "%10.5f")
method T (line 36499) | inline T operator() (parameter_list_t parameters)
type println (line 36509) | struct println : public exprtk::igeneric_function<T>
method println (line 36515) | println(const std::string& scalar_format = "%10.5f")
method T (line 36521) | inline T operator() (parameter_list_t parameters)
type package (line 36532) | struct package
method register_package (line 36537) | bool register_package(exprtk::symbol_table<T>& symtab)
type file (line 36565) | namespace file { namespace details
type details (line 36565) | namespace details
type file_mode (line 36567) | enum file_mode
type file_descriptor (line 36575) | struct file_descriptor
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function file_descriptor (line 36760) | file_descriptor* make_handle(T v)
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function perform_check (line 36771) | void perform_check()
class open (line 36789) | class open : public exprtk::igeneric_function<T>
method open (line 36800) | open()
method T (line 36804) | inline T operator() (const std::size_t& ps_index, parameter_li...
type close (line 36841) | struct close : public exprtk::ifunction<T>
method close (line 36845) | close()
method T (line 36849) | inline T operator() (const T& v)
class write (line 36863) | class write : public exprtk::igeneric_function<T>
method write (line 36876) | write()
method T (line 36880) | inline T operator() (const std::size_t& ps_index, parameter_li...
class read (line 36920) | class read : public exprtk::igeneric_function<T>
method read (line 36933) | read()
method T (line 36937) | inline T operator() (const std::size_t& ps_index, parameter_li...
class getline (line 36977) | class getline : public exprtk::igeneric_function<T>
method getline (line 36989) | getline()
method T (line 36993) | inline T operator() (std::string& result,
type eof (line 37002) | struct eof : public exprtk::ifunction<T>
method eof (line 37006) | eof()
method T (line 37010) | inline T operator() (const T& v)
type package (line 37019) | struct package
method register_package (line 37028) | bool register_package(exprtk::symbol_table<T>& symtab)
type io (line 36565) | namespace io { namespace file { namespace details
type details (line 36420) | namespace details
function print_type (line 36423) | inline void print_type(const std::string& fmt,
type print_impl (line 36431) | struct print_impl
method process (line 36440) | static void process(const std::string& scalar_format, paramete...
method print (line 36462) | static inline void print(const std::string& scalar_format, con...
method print (line 36467) | static inline void print(const std::string& scalar_format, con...
method print (line 36478) | static inline void print(const string_t& s)
type print (line 36487) | struct print : public exprtk::igeneric_function<T>
method print (line 36493) | print(const std::string& scalar_format = "%10.5f")
method T (line 36499) | inline T operator() (parameter_list_t parameters)
type println (line 36509) | struct println : public exprtk::igeneric_function<T>
method println (line 36515) | println(const std::string& scalar_format = "%10.5f")
method T (line 36521) | inline T operator() (parameter_list_t parameters)
type package (line 36532) | struct package
method register_package (line 36537) | bool register_package(exprtk::symbol_table<T>& symtab)
type file (line 36565) | namespace file { namespace details
type details (line 36565) | namespace details
type file_mode (line 36567) | enum file_mode
type file_descriptor (line 36575) | struct file_descriptor
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function file_descriptor (line 36760) | file_descriptor* make_handle(T v)
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function perform_check (line 36771) | void perform_check()
class open (line 36789) | class open : public exprtk::igeneric_function<T>
method open (line 36800) | open()
method T (line 36804) | inline T operator() (const std::size_t& ps_index, parameter_li...
type close (line 36841) | struct close : public exprtk::ifunction<T>
method close (line 36845) | close()
method T (line 36849) | inline T operator() (const T& v)
class write (line 36863) | class write : public exprtk::igeneric_function<T>
method write (line 36876) | write()
method T (line 36880) | inline T operator() (const std::size_t& ps_index, parameter_li...
class read (line 36920) | class read : public exprtk::igeneric_function<T>
method read (line 36933) | read()
method T (line 36937) | inline T operator() (const std::size_t& ps_index, parameter_li...
class getline (line 36977) | class getline : public exprtk::igeneric_function<T>
method getline (line 36989) | getline()
method T (line 36993) | inline T operator() (std::string& result,
type eof (line 37002) | struct eof : public exprtk::ifunction<T>
method eof (line 37006) | eof()
method T (line 37010) | inline T operator() (const T& v)
type package (line 37019) | struct package
method register_package (line 37028) | bool register_package(exprtk::symbol_table<T>& symtab)
type vecops (line 37060) | namespace vecops {
type helper (line 37062) | namespace helper
function invalid_range (line 37065) | inline bool invalid_range(const Vector& v, const std::size_t r0,...
type load_vector_range (line 37078) | struct load_vector_range
method process (line 37086) | static inline bool process(parameter_list_t& parameters,
type details (line 37109) | namespace details
function kahan_sum (line 37112) | inline void kahan_sum(T& sum, T& error, T v)
class all_true (line 37123) | class all_true : public exprtk::igeneric_function<T>
method all_true (line 37134) | all_true()
method T (line 37143) | inline T operator() (const std::size_t& ps_index, parameter_list...
class all_false (line 37169) | class all_false : public exprtk::igeneric_function<T>
method all_false (line 37180) | all_false()
method T (line 37189) | inline T operator() (const std::size_t& ps_index, parameter_list...
class any_true (line 37215) | class any_true : public exprtk::igeneric_function<T>
method any_true (line 37226) | any_true()
method T (line 37235) | inline T operator() (const std::size_t& ps_index, parameter_list...
class any_false (line 37261) | class any_false : public exprtk::igeneric_function<T>
method any_false (line 37272) | any_false()
method T (line 37281) | inline T operator() (const std::size_t& ps_index, parameter_list...
class count (line 37307) | class count : public exprtk::igeneric_function<T>
method count (line 37318) | count()
method T (line 37327) | inline T operator() (const std::size_t& ps_index, parameter_list...
class copy (line 37352) | class copy : public exprtk::igeneric_function<T>
method copy (line 37364) | copy()
method T (line 37373) | inline T operator() (const std::size_t& ps_index, parameter_list...
class rol (line 37402) | class rol : public exprtk::igeneric_function<T>
method rol (line 37414) | rol()
method T (line 37423) | inline T operator() (const std::size_t& ps_index, parameter_list...
class ror (line 37450) | class ror : public exprtk::igeneric_function<T>
method ror (line 37462) | ror()
method T (line 37471) | inline T operator() (const std::size_t& ps_index, parameter_list...
class shift_left (line 37498) | class shift_left : public exprtk::igeneric_function<T>
method shift_left (line 37510) | shift_left()
method T (line 37519) | inline T operator() (const std::size_t& ps_index, parameter_list...
class shift_right (line 37553) | class shift_right : public exprtk::igeneric_function<T>
method shift_right (line 37565) | shift_right()
method T (line 37574) | inline T operator() (const std::size_t& ps_index, parameter_list...
class sort (line 37610) | class sort : public exprtk::igeneric_function<T>
method sort (line 37622) | sort()
method T (line 37633) | inline T operator() (const std::size_t& ps_index, parameter_list...
class nthelement (line 37667) | class nthelement : public exprtk::igeneric_function<T>
method nthelement (line 37679) | nthelement()
method T (line 37688) | inline T operator() (const std::size_t& ps_index, parameter_list...
class iota (line 37709) | class iota : public exprtk::igeneric_function<T>
method iota (line 37721) | iota()
method T (line 37732) | inline T operator() (const std::size_t& ps_index, parameter_list...
class sumk (line 37761) | class sumk : public exprtk::igeneric_function<T>
method sumk (line 37772) | sumk()
method T (line 37781) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpy (line 37804) | class axpy : public exprtk::igeneric_function<T>
method axpy (line 37816) | axpy()
method T (line 37826) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpby (line 37851) | class axpby : public exprtk::igeneric_function<T>
method axpby (line 37863) | axpby()
method T (line 37873) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpyz (line 37899) | class axpyz : public exprtk::igeneric_function<T>
method axpyz (line 37911) | axpyz()
method T (line 37921) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpbyz (line 37949) | class axpbyz : public exprtk::igeneric_function<T>
method axpbyz (line 37961) | axpbyz()
method T (line 37971) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpbz (line 38000) | class axpbz : public exprtk::igeneric_function<T>
method axpbz (line 38012) | axpbz()
method T (line 38022) | inline T operator() (const std::size_t& ps_index, parameter_list...
class dot (line 38048) | class dot : public exprtk::igeneric_function<T>
method dot (line 38060) | dot()
method T (line 38069) | inline T operator() (const std::size_t& ps_index, parameter_list...
class dotk (line 38094) | class dotk : public exprtk::igeneric_function<T>
method dotk (line 38106) | dotk()
method T (line 38115) | inline T operator() (const std::size_t& ps_index, parameter_list...
type package (line 38141) | struct package
method register_package (line 38165) | bool register_package(exprtk::symbol_table<T>& symtab)
type rtl (line 37060) | namespace rtl { namespace vecops {
type io (line 36420) | namespace io { namespace details
type details (line 36420) | namespace details
function print_type (line 36423) | inline void print_type(const std::string& fmt,
type print_impl (line 36431) | struct print_impl
method process (line 36440) | static void process(const std::string& scalar_format, paramete...
method print (line 36462) | static inline void print(const std::string& scalar_format, con...
method print (line 36467) | static inline void print(const std::string& scalar_format, con...
method print (line 36478) | static inline void print(const string_t& s)
type print (line 36487) | struct print : public exprtk::igeneric_function<T>
method print (line 36493) | print(const std::string& scalar_format = "%10.5f")
method T (line 36499) | inline T operator() (parameter_list_t parameters)
type println (line 36509) | struct println : public exprtk::igeneric_function<T>
method println (line 36515) | println(const std::string& scalar_format = "%10.5f")
method T (line 36521) | inline T operator() (parameter_list_t parameters)
type package (line 36532) | struct package
method register_package (line 36537) | bool register_package(exprtk::symbol_table<T>& symtab)
type file (line 36565) | namespace file { namespace details
type details (line 36565) | namespace details
type file_mode (line 36567) | enum file_mode
type file_descriptor (line 36575) | struct file_descriptor
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function file_descriptor (line 36760) | file_descriptor* make_handle(T v)
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function perform_check (line 36771) | void perform_check()
class open (line 36789) | class open : public exprtk::igeneric_function<T>
method open (line 36800) | open()
method T (line 36804) | inline T operator() (const std::size_t& ps_index, parameter_li...
type close (line 36841) | struct close : public exprtk::ifunction<T>
method close (line 36845) | close()
method T (line 36849) | inline T operator() (const T& v)
class write (line 36863) | class write : public exprtk::igeneric_function<T>
method write (line 36876) | write()
method T (line 36880) | inline T operator() (const std::size_t& ps_index, parameter_li...
class read (line 36920) | class read : public exprtk::igeneric_function<T>
method read (line 36933) | read()
method T (line 36937) | inline T operator() (const std::size_t& ps_index, parameter_li...
class getline (line 36977) | class getline : public exprtk::igeneric_function<T>
method getline (line 36989) | getline()
method T (line 36993) | inline T operator() (std::string& result,
type eof (line 37002) | struct eof : public exprtk::ifunction<T>
method eof (line 37006) | eof()
method T (line 37010) | inline T operator() (const T& v)
type package (line 37019) | struct package
method register_package (line 37028) | bool register_package(exprtk::symbol_table<T>& symtab)
type io (line 36565) | namespace io { namespace file { namespace details
type details (line 36420) | namespace details
function print_type (line 36423) | inline void print_type(const std::string& fmt,
type print_impl (line 36431) | struct print_impl
method process (line 36440) | static void process(const std::string& scalar_format, paramete...
method print (line 36462) | static inline void print(const std::string& scalar_format, con...
method print (line 36467) | static inline void print(const std::string& scalar_format, con...
method print (line 36478) | static inline void print(const string_t& s)
type print (line 36487) | struct print : public exprtk::igeneric_function<T>
method print (line 36493) | print(const std::string& scalar_format = "%10.5f")
method T (line 36499) | inline T operator() (parameter_list_t parameters)
type println (line 36509) | struct println : public exprtk::igeneric_function<T>
method println (line 36515) | println(const std::string& scalar_format = "%10.5f")
method T (line 36521) | inline T operator() (parameter_list_t parameters)
type package (line 36532) | struct package
method register_package (line 36537) | bool register_package(exprtk::symbol_table<T>& symtab)
type file (line 36565) | namespace file { namespace details
type details (line 36565) | namespace details
type file_mode (line 36567) | enum file_mode
type file_descriptor (line 36575) | struct file_descriptor
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function file_descriptor (line 36760) | file_descriptor* make_handle(T v)
method file_descriptor (line 36577) | file_descriptor(const std::string& fname, const std::string&...
method open (line 36587) | bool open()
method close (line 36642) | void close(Ptr& p)
method close (line 36650) | bool close()
method write (line 36670) | bool write(const View& view, const std::size_t amount, const...
method read (line 36689) | bool read(View& view, const std::size_t amount, const std::s...
method getline (line 36707) | bool getline(std::string& s)
method eof (line 36717) | bool eof()
method file_mode (line 36728) | file_mode get_file_mode(const std::string& access)
function perform_check (line 36771) | void perform_check()
class open (line 36789) | class open : public exprtk::igeneric_function<T>
method open (line 36800) | open()
method T (line 36804) | inline T operator() (const std::size_t& ps_index, parameter_li...
type close (line 36841) | struct close : public exprtk::ifunction<T>
method close (line 36845) | close()
method T (line 36849) | inline T operator() (const T& v)
class write (line 36863) | class write : public exprtk::igeneric_function<T>
method write (line 36876) | write()
method T (line 36880) | inline T operator() (const std::size_t& ps_index, parameter_li...
class read (line 36920) | class read : public exprtk::igeneric_function<T>
method read (line 36933) | read()
method T (line 36937) | inline T operator() (const std::size_t& ps_index, parameter_li...
class getline (line 36977) | class getline : public exprtk::igeneric_function<T>
method getline (line 36989) | getline()
method T (line 36993) | inline T operator() (std::string& result,
type eof (line 37002) | struct eof : public exprtk::ifunction<T>
method eof (line 37006) | eof()
method T (line 37010) | inline T operator() (const T& v)
type package (line 37019) | struct package
method register_package (line 37028) | bool register_package(exprtk::symbol_table<T>& symtab)
type vecops (line 37060) | namespace vecops {
type helper (line 37062) | namespace helper
function invalid_range (line 37065) | inline bool invalid_range(const Vector& v, const std::size_t r0,...
type load_vector_range (line 37078) | struct load_vector_range
method process (line 37086) | static inline bool process(parameter_list_t& parameters,
type details (line 37109) | namespace details
function kahan_sum (line 37112) | inline void kahan_sum(T& sum, T& error, T v)
class all_true (line 37123) | class all_true : public exprtk::igeneric_function<T>
method all_true (line 37134) | all_true()
method T (line 37143) | inline T operator() (const std::size_t& ps_index, parameter_list...
class all_false (line 37169) | class all_false : public exprtk::igeneric_function<T>
method all_false (line 37180) | all_false()
method T (line 37189) | inline T operator() (const std::size_t& ps_index, parameter_list...
class any_true (line 37215) | class any_true : public exprtk::igeneric_function<T>
method any_true (line 37226) | any_true()
method T (line 37235) | inline T operator() (const std::size_t& ps_index, parameter_list...
class any_false (line 37261) | class any_false : public exprtk::igeneric_function<T>
method any_false (line 37272) | any_false()
method T (line 37281) | inline T operator() (const std::size_t& ps_index, parameter_list...
class count (line 37307) | class count : public exprtk::igeneric_function<T>
method count (line 37318) | count()
method T (line 37327) | inline T operator() (const std::size_t& ps_index, parameter_list...
class copy (line 37352) | class copy : public exprtk::igeneric_function<T>
method copy (line 37364) | copy()
method T (line 37373) | inline T operator() (const std::size_t& ps_index, parameter_list...
class rol (line 37402) | class rol : public exprtk::igeneric_function<T>
method rol (line 37414) | rol()
method T (line 37423) | inline T operator() (const std::size_t& ps_index, parameter_list...
class ror (line 37450) | class ror : public exprtk::igeneric_function<T>
method ror (line 37462) | ror()
method T (line 37471) | inline T operator() (const std::size_t& ps_index, parameter_list...
class shift_left (line 37498) | class shift_left : public exprtk::igeneric_function<T>
method shift_left (line 37510) | shift_left()
method T (line 37519) | inline T operator() (const std::size_t& ps_index, parameter_list...
class shift_right (line 37553) | class shift_right : public exprtk::igeneric_function<T>
method shift_right (line 37565) | shift_right()
method T (line 37574) | inline T operator() (const std::size_t& ps_index, parameter_list...
class sort (line 37610) | class sort : public exprtk::igeneric_function<T>
method sort (line 37622) | sort()
method T (line 37633) | inline T operator() (const std::size_t& ps_index, parameter_list...
class nthelement (line 37667) | class nthelement : public exprtk::igeneric_function<T>
method nthelement (line 37679) | nthelement()
method T (line 37688) | inline T operator() (const std::size_t& ps_index, parameter_list...
class iota (line 37709) | class iota : public exprtk::igeneric_function<T>
method iota (line 37721) | iota()
method T (line 37732) | inline T operator() (const std::size_t& ps_index, parameter_list...
class sumk (line 37761) | class sumk : public exprtk::igeneric_function<T>
method sumk (line 37772) | sumk()
method T (line 37781) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpy (line 37804) | class axpy : public exprtk::igeneric_function<T>
method axpy (line 37816) | axpy()
method T (line 37826) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpby (line 37851) | class axpby : public exprtk::igeneric_function<T>
method axpby (line 37863) | axpby()
method T (line 37873) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpyz (line 37899) | class axpyz : public exprtk::igeneric_function<T>
method axpyz (line 37911) | axpyz()
method T (line 37921) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpbyz (line 37949) | class axpbyz : public exprtk::igeneric_function<T>
method axpbyz (line 37961) | axpbyz()
method T (line 37971) | inline T operator() (const std::size_t& ps_index, parameter_list...
class axpbz (line 38000) | class axpbz : public exprtk::igeneric_function<T>
method axpbz (line 38012) | axpbz()
method T (line 38022) | inline T operator() (const std::size_t& ps_index, parameter_list...
class dot (line 38048) | class dot : public exprtk::igeneric_function<T>
method dot (line 38060) | dot()
method T (line 38069) | inline T operator() (const std::size_t& ps_index, parameter_list...
class dotk (line 38094) | class dotk : public exprtk::igeneric_function<T>
method dotk (line 38106) | dotk()
method T (line 38115) | inline T operator() (const std::size_t& ps_index, parameter_list...
type package (line 38141) | struct package
method register_package (line 38165) | bool register_package(exprtk::symbol_table<T>& symtab)
type information (line 38212) | namespace information
function data (line 38219) | static inline std::string data()
type lexer (line 2015) | namespace lexer
type token (line 2017) | struct token
type token_type (line 2019) | enum token_type
method token (line 2037) | token()
method clear (line 2043) | void clear()
method token (line 2051) | inline token& set_operator(const token_type tt,
method token (line 2063) | inline token& set_symbol(const Iterator begin, const Iterator end, c...
method token (line 2073) | inline token& set_numeric(const Iterator begin, const Iterator end, ...
method token (line 2083) | inline token& set_string(const Iterator begin, const Iterator end, c...
method token (line 2092) | inline token& set_string(const std::string& s, const std::size_t p)
method token (line 2101) | inline token& set_error(const token_type et,
method to_str (line 2126) | static inline std::string to_str(token_type t)
method is_error (line 2173) | inline bool is_error() const
function scan_operator (line 2189) | class generator
function scan_symbol (line 2525) | inline void scan_symbol()
function scan_number (line 2557) | inline void scan_number()
function scan_special_function (line 2663) | inline void scan_special_function()
function scan_string (line 2699) | inline void scan_string()
class helper_interface (line 2815) | class helper_interface
method init (line 2819) | virtual void init() { }
method reset (line 2820) | virtual void reset() { }
method result (line 2821) | virtual bool result() { return true; }
method process (line 2822) | virtual std::size_t process(generator&) { return 0; }
class token_scanner (line 2826) | class token_scanner : public helper_interface
method token_scanner (line 2833) | explicit token_scanner(const std::size_t& stride)
method process (line 2842) | inline std::size_t process(generator& g)
class token_modifier (line 2933) | class token_modifier : public helper_interface
method process (line 2937) | inline std::size_t process(generator& g)
class token_inserter (line 2952) | class token_inserter : public helper_interface
method token_inserter (line 2956) | explicit token_inserter(const std::size_t& stride)
method process (line 2965) | inline std::size_t process(generator& g)
class token_joiner (line 3038) | class token_joiner : public helper_interface
method token_joiner (line 3042) | token_joiner(const std::size_t& stride)
method process (line 3046) | inline std::size_t process(generator& g)
method join (line 3059) | virtual bool join(const token&, const token&, token&) { ...
method join (line 3060) | virtual bool join(const token&, const token&, const token&, token&) { ...
method process_stride_2 (line 3064) | inline std::size_t process_stride_2(generator& g)
method process_stride_3 (line 3090) | inline std::size_t process_stride_3(generator& g)
type helper (line 3119) | namespace helper
function dump (line 3122) | inline void dump(lexer::generator& generator)
class commutative_inserter (line 3135) | class commutative_inserter : public lexer::token_inserter
method commutative_inserter (line 3141) | commutative_inserter()
method ignore_symbol (line 3145) | inline void ignore_symbol(const std::string& symbol)
method insert (line 3150) | inline int insert(const lexer::token& t0, const lexer::token& t1, le...
class operator_joiner (line 3196) | class operator_joiner : public token_joiner
method operator_joiner (line 3200) | operator_joiner(const std::size_t& stride)
method join (line 3204) | inline bool join(const lexer::token& t0, const lexer::token& t1, lex...
method join (line 3349) | inline bool join(const lexer::token& t0, const lexer::token& t1, con...
class bracket_checker (line 3369) | class bracket_checker : public lexer::token_scanner
method bracket_checker (line 3375) | bracket_checker()
method result (line 3380) | bool result()
method error_token (line 3396) | lexer::token error_token()
method reset (line 3401) | void reset()
class numeric_checker (line 3454) | class numeric_checker : public lexer::token_scanner
method numeric_checker (line 3460) | numeric_checker()
method result (line 3465) | bool result()
method reset (line 3470) | void reset()
method error_count (line 3493) | std::size_t error_count() const
method error_index (line 3498) | std::size_t error_index(const std::size_t& i)
method clear_errors (line 3506) | void clear_errors()
class symbol_replacer (line 3517) | class symbol_replacer : public lexer::token_modifier
method remove (line 3525) | bool remove(const std::string& target_symbol)
method add_replace (line 3537) | bool add_replace(const std::string& target_symbol,
method clear (line 3553) | void clear()
method modify (line 3560) | bool modify(lexer::token& t)
class sequence_validator (line 3584) | class sequence_validator : public lexer::token_scanner
method sequence_validator (line 3595) | sequence_validator()
method result (line 3622) | bool result()
method error_count (line 3643) | std::size_t error_count()
method error (line 3648) | std::pair<lexer::token,lexer::token> error(const std::size_t index)
method clear_errors (line 3661) | void clear_errors()
method add_invalid (line 3668) | void add_invalid(lexer::token::token_type base, lexer::token::token_...
method add_invalid_set1 (line 3673) | void add_invalid_set1(lexer::token::token_type t)
method invalid_bracket_check (line 3692) | bool invalid_bracket_check(lexer::token::token_type base, lexer::tok...
type helper_assembly (line 3755) | struct helper_assembly
method register_scanner (line 3757) | inline bool register_scanner(lexer::token_scanner* scanner)
method register_modifier (line 3771) | inline bool register_modifier(lexer::token_modifier* modifier)
method register_joiner (line 3785) | inline bool register_joiner(lexer::token_joiner* joiner)
method register_inserter (line 3799) | inline bool register_inserter(lexer::token_inserter* inserter)
method run_modifiers (line 3813) | inline bool run_modifiers(lexer::generator& g)
method run_joiners (line 3835) | inline bool run_joiners(lexer::generator& g)
method run_inserters (line 3857) | inline bool run_inserters(lexer::generator& g)
method run_scanners (line 3879) | inline bool run_scanners(lexer::generator& g)
class parser_helper (line 3913) | class parser_helper
method init (line 3920) | inline bool init(const std::string& str)
method generator_t (line 3934) | inline generator_t& lexer()
method generator_t (line 3939) | inline const generator_t& lexer() const
method store_token (line 3944) | inline void store_token()
method restore_token (line 3950) | inline void restore_token()
method next_token (line 3956) | inline void next_token()
method token_t (line 3961) | inline const token_t& current_token() const
type token_advance_mode (line 3966) | enum token_advance_mode
method advance_token (line 3972) | inline void advance_token(const token_advance_mode mode)
method token_is (line 3980) | inline bool token_is(const token_t::token_type& ttype, const token_adv...
method token_is (line 3992) | inline bool token_is(const token_t::token_type& ttype,
method token_is_then_assign (line 4009) | inline bool token_is_then_assign(const token_t::token_type& ttype,
method token_is_then_assign (line 4027) | inline bool token_is_then_assign(const token_t::token_type& ttype,
method peek_token_is (line 4043) | inline bool peek_token_is(const token_t::token_type& ttype)
method peek_token_is (line 4048) | inline bool peek_token_is(const std::string& s)
class vector_view (line 4062) | class vector_view
method vector_view (line 4068) | vector_view(data_ptr_t data, const std::size_t& size)
method vector_view (line 4074) | vector_view(const vector_view<T>& vv)
method rebase (line 4080) | inline void rebase(data_ptr_t data)
method data_ptr_t (line 4093) | inline data_ptr_t data() const
method size (line 4098) | inline std::size_t size() const
method T (line 4103) | inline const T& operator[](const std::size_t index) const
method T (line 4108) | inline T& operator[](const std::size_t index)
method set_ref (line 4113) | void set_ref(data_ptr_t* data_ref)
function make_vector_view (line 4126) | inline vector_view<T> make_vector_view(T* data,
function make_vector_view (line 4133) | inline vector_view<T> make_vector_view(std::vector<T>& v,
class results_context (line 4139) | class results_context
method results_context (line 4340) | results_context()
method count (line 4344) | inline std::size_t count() const
method type_store_t (line 4352) | inline type_store_t& operator[](const std::size_t& index)
method type_store_t (line 4357) | inline const type_store_t& operator[](const std::size_t& index) const
method clear (line 4364) | inline void clear()
method assign (line 4372) | inline void assign(const parameter_list_t& pl)
type type_store (line 4142) | struct type_store
type store_type (line 4144) | enum store_type
method type_store (line 4152) | type_store()
class parameter_list (line 4162) | class parameter_list
method parameter_list (line 4166) | parameter_list(std::vector<type_store>& pl)
method empty (line 4170) | inline bool empty() const
method size (line 4175) | inline std::size_t size() const
method type_store (line 4180) | inline type_store& operator[](const std::size_t& index)
method type_store (line 4185) | inline const type_store& operator[](const std::size_t& index) const
method type_store (line 4190) | inline type_store& front()
method type_store (line 4195) | inline const type_store& front() const
method type_store (line 4200) | inline type_store& back()
method type_store (line 4205) | inline const type_store& back() const
type type_view (line 4218) | struct type_view
method type_view (line 4223) | type_view(type_store_t& ts)
method type_view (line 4228) | type_view(const type_store_t& ts)
method size (line 4233) | inline std::size_t size() const
method value_t (line 4238) | inline value_t& operator[](const std::size_t& i)
method value_t (line 4243) | inline const value_t& operator[](const std::size_t& i) const
method value_t (line 4248) | inline const value_t* begin() const { return data_; }
method value_t (line 4249) | inline value_t* begin() { return data_; }
method value_t (line 4251) | inline const value_t* end() const
method value_t (line 4256) | inline value_t* end()
type scalar_view (line 4268) | struct scalar_view
method scalar_view (line 4273) | scalar_view(type_store_t& ts)
method scalar_view (line 4277) | scalar_view(const type_store_t& ts)
method value_t (line 4281) | inline value_t& operator() ()
method value_t (line 4286) | inline const value_t& operator() () const
method to_int (line 4292) | inline bool to_int(IntType& i) const
method to_uint (line 4303) | inline bool to_uint(UIntType& u) const
function to_str (line 4320) | inline std::string to_str(const StringView& view)
type details (line 4326) | namespace details
class return_node (line 4328) | class return_node
class return_envelope_node (line 4329) | class return_envelope_node
type operator_type (line 4389) | enum operator_type
function to_str (line 4461) | inline std::string to_str(const operator_type opr)
type base_operation_t (line 4489) | struct base_operation_t
method base_operation_t (line 4491) | base_operation_t(const operator_type t, const unsigned int& np)
type loop_unroll (line 4500) | namespace loop_unroll
type details (line 4508) | struct details
method details (line 4510) | details(const std::size_t& vsize,
function dump_ptr (line 4524) | inline void dump_ptr(const std::string& s, const void* ptr, const std:...
function dump_ptr (line 4535) | inline void dump_ptr(const std::string&, const void*) {}
function dump_ptr (line 4536) | inline void dump_ptr(const std::string&, const void*, const std::size_...
class vec_data_store (line 4540) | class vec_data_store
type control_block (line 4549) | struct control_block
method control_block (line 4551) | control_block()
method control_block (line 4558) | control_block(const std::size_t& dsize)
method control_block (line 4565) | control_block(const std::size_t& dsize, data_t dptr, bool dstrct =...
method control_block (line 4582) | static inline control_block* create(const std::size_t& dsize, data...
method destroy (line 4595) | static inline void destroy(control_block*& cntrl_blck)
method create_data (line 4621) | inline void create_data()
method vec_data_store (line 4632) | vec_data_store()
method vec_data_store (line 4636) | vec_data_store(const std::size_t& size)
method vec_data_store (line 4640) | vec_data_store(const std::size_t& size, data_t data, bool dstrct = f...
method vec_data_store (line 4644) | vec_data_store(const type& vds)
method type (line 4655) | type& operator=(const type& vds)
method data_t (line 4676) | inline data_t data()
method data_t (line 4681) | inline data_t data() const
method size (line 4686) | inline std::size_t size()
method size (line 4691) | inline std::size_t size() const
method data_t (line 4696) | inline data_t& ref()
method dump (line 4701) | inline void dump() const
method match_sizes (line 4720) | static inline void match_sizes(type& vds0, type& vds1)
method min_size (line 4729) | static inline std::size_t min_size(control_block* cb0, control_block...
type numeric (line 4743) | namespace numeric
type details (line 4745) | namespace details
function T (line 4748) | inline T process_impl(const operator_type operation, const T arg)
function T (line 4799) | inline T process_impl(const operator_type operation, const T arg0,...
function T (line 4839) | inline T process_impl(const operator_type operation, const T arg0,...
function T (line 4878) | inline T process(const operator_type operation, const T arg)
function T (line 4884) | inline T process(const operator_type operation, const T arg0, const ...
class expression_node (line 4891) | class expression_node
type node_type (line 4895) | enum node_type
method T (line 4942) | inline virtual T value() const
method node_type (line 4952) | inline virtual node_type type() const
function is_true (line 4961) | inline bool is_true(const double v)
function is_true (line 4966) | inline bool is_true(const long double v)
function is_true (line 4971) | inline bool is_true(const float v)
function is_true (line 4977) | inline bool is_true(const std::complex<T>& v)
function is_true (line 4983) | inline bool is_true(const expression_node<T>* node)
function is_false (line 4989) | inline bool is_false(const expression_node<T>* node)
function is_unary_node (line 4995) | inline bool is_unary_node(const expression_node<T>* node)
function is_neg_unary_node (line 5001) | inline bool is_neg_unary_node(const expression_node<T>* node)
function is_binary_node (line 5007) | inline bool is_binary_node(const expression_node<T>* node)
function is_variable_node (line 5013) | inline bool is_variable_node(const expression_node<T>* node)
function is_ivariable_node (line 5019) | inline bool is_ivariable_node(const expression_node<T>* node)
function is_vector_elem_node (line 5031) | inline bool is_vector_elem_node(const expression_node<T>* node)
function is_rebasevector_elem_node (line 5037) | inline bool is_rebasevector_elem_node(const expression_node<T>* node)
function is_rebasevector_celem_node (line 5043) | inline bool is_rebasevector_celem_node(const expression_node<T>* node)
function is_vector_node (line 5049) | inline bool is_vector_node(const expression_node<T>* node)
function is_ivector_node (line 5055) | inline bool is_ivector_node(const expression_node<T>* node)
function is_constant_node (line 5079) | inline bool is_constant_node(const expression_node<T>* node)
function is_null_node (line 5085) | inline bool is_null_node(const expression_node<T>* node)
function is_break_node (line 5091) | inline bool is_break_node(const expression_node<T>* node)
function is_continue_node (line 5097) | inline bool is_continue_node(const expression_node<T>* node)
function is_swap_node (line 5103) | inline bool is_swap_node(const expression_node<T>* node)
function is_function (line 5109) | inline bool is_function(const expression_node<T>* node)
function is_return_node (line 5115) | inline bool is_return_node(const expression_node<T>* node)
class unary_node (line 5120) | class unary_node
method unary_node (line 5653) | unary_node(const operator_type& opr,
method T (line 5668) | inline T value() const
method type (line 5675) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5680) | inline operator_type operation() const
method release (line 5690) | inline void release()
function is_negate_node (line 5123) | inline bool is_negate_node(const expression_node<T>* node)
function branch_deletable (line 5134) | inline bool branch_deletable(expression_node<T>* node)
function all_nodes_valid (line 5141) | inline bool all_nodes_valid(expression_node<T>* (&b)[N])
function all_nodes_valid (line 5154) | inline bool all_nodes_valid(const Sequence<expression_node<T>*,Allocat...
function all_nodes_variables (line 5165) | inline bool all_nodes_variables(expression_node<T>* (&b)[N])
function all_nodes_variables (line 5181) | inline bool all_nodes_variables(Sequence<expression_node<T>*,Allocator...
function free_all_nodes (line 5195) | inline void free_all_nodes(NodeAllocator& node_allocator, expression_n...
function free_all_nodes (line 5207) | inline void free_all_nodes(NodeAllocator& node_allocator, Sequence<exp...
function free_node (line 5218) | inline void free_node(NodeAllocator& node_allocator, expression_node<T...
function destroy_node (line 5234) | inline void destroy_node(expression_node<T>*& node)
class vector_holder (line 5241) | class vector_holder
class vector_holder_base (line 5249) | class vector_holder_base
method value_ptr (line 5255) | inline value_ptr operator[](const std::size_t& index) const
method size (line 5260) | inline std::size_t size() const
method value_ptr (line 5265) | inline value_ptr data() const
method rebaseable (line 5270) | virtual inline bool rebaseable() const
method set_ref (line 5275) | virtual void set_ref(value_ptr*) {}
class array_vector_impl (line 5283) | class array_vector_impl : public vector_holder_base
method array_vector_impl (line 5287) | array_vector_impl(const Type* vec, const std::size_t& vec_size)
method value_ptr (line 5294) | value_ptr value_at(const std::size_t& index) const
method vector_size (line 5302) | std::size_t vector_size() const
class sequence_vector_impl (line 5317) | class sequence_vector_impl : public vector_holder_base
method sequence_vector_impl (line 5323) | sequence_vector_impl(sequence_t& seq)
method value_ptr (line 5329) | value_ptr value_at(const std::size_t& index) const
method vector_size (line 5334) | std::size_t vector_size() const
class vector_view_impl (line 5346) | class vector_view_impl : public vector_holder_base
method vector_view_impl (line 5352) | vector_view_impl(vector_view_t& vec_view)
method set_ref (line 5356) | void set_ref(value_ptr* ref)
method rebaseable (line 5361) | virtual inline bool rebaseable() const
method value_ptr (line 5368) | value_ptr value_at(const std::size_t& index) const
method vector_size (line 5373) | std::size_t vector_size() const
method vector_holder (line 5389) | vector_holder(Type* vec, const std::size_t& vec_size)
method vector_holder (line 5393) | vector_holder(const vds_t& vds)
method vector_holder (line 5398) | vector_holder(std::vector<Type,Allocator>& vec)
method vector_holder (line 5402) | vector_holder(exprtk::vector_view<Type>& vec)
method value_ptr (line 5406) | inline value_ptr operator[](const std::size_t& index) const
method size (line 5411) | inline std::size_t size() const
method value_ptr (line 5416) | inline value_ptr data() const
method set_ref (line 5421) | void set_ref(value_ptr* ref)
method rebaseable (line 5426) | bool rebaseable() const
class null_node (line 5438) | class null_node : public expression_node<T>
method T (line 5442) | inline T value() const
method type (line 5447) | inline typename expression_node<T>::node_type type() const
class null_eq_node (line 5454) | class null_eq_node : public expression_node<T>
method null_eq_node (line 5460) | null_eq_node(expression_ptr brnch, const bool equality = true)
method T (line 5474) | inline T value() const
method type (line 5485) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5490) | inline operator_type operation() const
class literal_node (line 5508) | class literal_node : public expression_node<T>
method literal_node (line 5512) | explicit literal_node(const T& v)
method T (line 5516) | inline T value() const
method type (line 5521) | inline typename expression_node<T>::node_type type() const
method literal_node (line 5533) | literal_node(literal_node<T>&) {}
type range_pack (line 5540) | struct range_pack
method range_pack (line 6830) | range_pack()
method clear (line 6838) | void clear()
method free (line 6847) | void free()
method const_range (line 6876) | bool const_range()
method var_range (line 6882) | bool var_range()
method const_size (line 6932) | inline std::size_t const_size() const
method cache_size (line 6937) | inline std::size_t cache_size() const
type range_data_type (line 5543) | struct range_data_type
method range_data_type (line 6958) | range_data_type()
class range_interface (line 5546) | class range_interface
class string_base_node (line 5562) | class string_base_node
class string_literal_node (line 5579) | class string_literal_node : public expression_node <T>,
method string_literal_node (line 5587) | explicit string_literal_node(const std::string& v)
method T (line 5596) | inline T value() const
method type (line 5601) | inline typename expression_node<T>::node_type type() const
method str (line 5611) | std::string str() const
method char_t (line 5616) | const char_t* base() const
method size (line 5621) | std::size_t size() const
method range_t (line 5626) | range_t& range_ref()
method range_t (line 5631) | const range_t& range_ref() const
class unary_node (line 5647) | class unary_node : public expression_node<T>
method unary_node (line 5653) | unary_node(const operator_type& opr,
method T (line 5668) | inline T value() const
method type (line 5675) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5680) | inline operator_type operation() const
method release (line 5690) | inline void release()
type construct_branch_pair (line 5703) | struct construct_branch_pair
method process (line 5706) | static inline void process(std::pair<expression_node<T>*,bool> (&)[N...
type construct_branch_pair<T,D,true> (line 5711) | struct construct_branch_pair<T,D,true>
method process (line 5714) | static inline void process(std::pair<expression_node<T>*,bool> (&bra...
function init_branches (line 5724) | inline void init_branches(std::pair<expression_node<T>*,bool> (&branch...
type cleanup_branches (line 5748) | struct cleanup_branches
method execute (line 5751) | static inline void execute(std::pair<expression_node<T>*,bool> (&bra...
method execute (line 5765) | static inline void execute(Sequence<std::pair<expression_node<T>*,bo...
class binary_node (line 5778) | class binary_node : public expression_node<T>
method binary_node (line 5785) | binary_node(const operator_type& opr,
method T (line 5798) | inline T value() const
method type (line 5806) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5811) | inline operator_type operation()
class binary_ext_node (line 5833) | class binary_ext_node : public expression_node<T>
method binary_ext_node (line 5840) | binary_ext_node(expression_ptr branch0, expression_ptr branch1)
method T (line 5850) | inline T value() const
method type (line 5858) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5863) | inline operator_type operation()
class trinary_node (line 5884) | class trinary_node : public expression_node<T>
method trinary_node (line 5891) | trinary_node(const operator_type& opr,
method T (line 5905) | inline T value() const
method type (line 5929) | inline typename expression_node<T>::node_type type() const
class quaternary_node (line 5941) | class quaternary_node : public expression_node<T>
method quaternary_node (line 5948) | quaternary_node(const operator_type& opr,
method T (line 5963) | inline T value() const
method type (line 5968) | inline typename expression_node<T>::node_type type() const
class conditional_node (line 5980) | class conditional_node : public expression_node<T>
method conditional_node (line 5986) | conditional_node(expression_ptr test,
method T (line 6015) | inline T value() const
method type (line 6023) | inline typename expression_node<T>::node_type type() const
class cons_conditional_node (line 6039) | class cons_conditional_node : public expression_node<T>
method cons_conditional_node (line 6046) | cons_conditional_node(expression_ptr test,
method T (line 6067) | inline T value() const
method type (line 6075) | inline typename expression_node<T>::node_type type() const
class break_exception (line 6090) | class break_exception
method break_exception (line 6094) | break_exception(const T& v)
class continue_exception (line 6101) | class continue_exception
class break_node (line 6105) | class break_node : public expression_node<T>
method break_node (line 6111) | break_node(expression_ptr ret = expression_ptr(0))
method T (line 6124) | inline T value() const
method type (line 6132) | inline typename expression_node<T>::node_type type() const
class continue_node (line 6144) | class continue_node : public expression_node<T>
method T (line 6148) | inline T value() const
method type (line 6156) | inline typename expression_node<T>::node_type type() const
class while_loop_node (line 6164) | class while_loop_node : public expression_node<T>
method while_loop_node (line 6170) | while_loop_node(expression_ptr condition, expression_ptr loop_body)
method T (line 6190) | inline T value() const
method type (line 6202) | inline typename expression_node<T>::node_type type() const
class repeat_until_loop_node (line 6216) | class repeat_until_loop_node : public expression_node<T>
method repeat_until_loop_node (line 6222) | repeat_until_loop_node(expression_ptr condition, expression_ptr loop...
method T (line 6242) | inline T value() const
method type (line 6255) | inline typename expression_node<T>::node_type type() const
class for_loop_node (line 6269) | class for_loop_node : public expression_node<T>
method for_loop_node (line 6275) | for_loop_node(expression_ptr initialiser,
method T (line 6312) | inline T value() const
method type (line 6338) | inline typename expression_node<T>::node_type type() const
class while_loop_bc_node (line 6357) | class while_loop_bc_node : public expression_node<T>
method while_loop_bc_node (line 6363) | while_loop_bc_node(expression_ptr condition, expression_ptr loop_body)
method T (line 6383) | inline T value() const
method type (line 6404) | inline typename expression_node<T>::node_type type() const
class repeat_until_loop_bc_node (line 6418) | class repeat_until_loop_bc_node : public expression_node<T>
method repeat_until_loop_bc_node (line 6424) | repeat_until_loop_bc_node(expression_ptr condition, expression_ptr l...
method T (line 6444) | inline T value() const
method type (line 6466) | inline typename expression_node<T>::node_type type() const
class for_loop_bc_node (line 6480) | class for_loop_bc_node : public expression_node<T>
method for_loop_bc_node (line 6486) | for_loop_bc_node(expression_ptr initialiser,
method T (line 6523) | inline T value() const
method type (line 6568) | inline typename expression_node<T>::node_type type() const
class switch_node (line 6587) | class switch_node : public expression_node<T>
method switch_node (line 6595) | switch_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 6630) | inline T value() const
method type (line 6653) | inline typename expression_node<T>::node_type type() const
class switch_n_node (line 6665) | class switch_n_node : public switch_node<T>
method switch_n_node (line 6673) | switch_n_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 6677) | inline T value() const
class multi_switch_node (line 6684) | class multi_switch_node : public expression_node<T>
method multi_switch_node (line 6692) | multi_switch_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 6727) | inline T value() const
method type (line 6752) | inline typename expression_node<T>::node_type type() const
class ivariable (line 6764) | class ivariable
class variable_node (line 6776) | class variable_node : public expression_node<T>,
method variable_node (line 6783) | explicit variable_node()
method variable_node (line 6787) | variable_node(T& v)
method T (line 6796) | inline T value() const
method T (line 6801) | inline T& ref()
method T (line 6806) | inline const T& ref() const
method type (line 6811) | inline typename expression_node<T>::node_type type() const
type range_pack (line 6825) | struct range_pack
method range_pack (line 6830) | range_pack()
method clear (line 6838) | void clear()
method free (line 6847) | void free()
method const_range (line 6876) | bool const_range()
method var_range (line 6882) | bool var_range()
method const_size (line 6932) | inline std::size_t const_size() const
method cache_size (line 6937) | inline std::size_t cache_size() const
class string_base_node (line 6950) | class string_base_node
type range_data_type (line 6953) | struct range_data_type
method range_data_type (line 6958) | range_data_type()
class vector_node (line 6973) | class vector_node
method vector_node (line 7010) | vector_node(vector_holder_t* vh)
method vector_node (line 7017) | vector_node(const vds_t& vds, vector_holder_t* vh)
method T (line 7022) | inline T value() const
method vector_node_ptr (line 7027) | vector_node_ptr vec() const
method vector_node_ptr (line 7032) | vector_node_ptr vec()
method type (line 7037) | inline typename expression_node<T>::node_type type() const
method size (line 7042) | std::size_t size() const
method vds_t (line 7047) | vds_t& vds()
method vds_t (line 7052) | const vds_t& vds() const
method vector_holder_t (line 7057) | inline vector_holder_t& vec_holder()
class vector_interface (line 6976) | class vector_interface
method side_effect (line 6996) | virtual bool side_effect () const { return false; }
class vector_node (line 7000) | class vector_node : public expression_node <T>,
method vector_node (line 7010) | vector_node(vector_holder_t* vh)
method vector_node (line 7017) | vector_node(const vds_t& vds, vector_holder_t* vh)
method T (line 7022) | inline T value() const
method vector_node_ptr (line 7027) | vector_node_ptr vec() const
method vector_node_ptr (line 7032) | vector_node_ptr vec()
method type (line 7037) | inline typename expression_node<T>::node_type type() const
method size (line 7042) | std::size_t size() const
method vds_t (line 7047) | vds_t& vds()
method vds_t (line 7052) | const vds_t& vds() const
method vector_holder_t (line 7057) | inline vector_holder_t& vec_holder()
class vector_elem_node (line 7069) | class vector_elem_node : public expression_node<T>,
method vector_elem_node (line 7078) | vector_elem_node(expression_ptr index, vector_holder_ptr vec_holder)
method T (line 7093) | inline T value() const
method T (line 7098) | inline T& ref()
method T (line 7103) | inline const T& ref() const
method type (line 7108) | inline typename expression_node<T>::node_type type() const
method vector_holder_t (line 7113) | inline vector_holder_t& vec_holder()
class rebasevector_elem_node (line 7127) | class rebasevector_elem_node : public expression_node<T>,
method rebasevector_elem_node (line 7137) | rebasevector_elem_node(expression_ptr index, vector_holder_ptr vec_h...
method T (line 7154) | inline T value() const
method T (line 7159) | inline T& ref()
method T (line 7164) | inline const T& ref() const
method type (line 7169) | inline typename expression_node<T>::node_type type() const
method vector_holder_t (line 7174) | inline vector_holder_t& vec_holder()
class rebasevector_celem_node (line 7188) | class rebasevector_celem_node : public expression_node<T>,
method rebasevector_celem_node (line 7198) | rebasevector_celem_node(const std::size_t index, vector_holder_ptr v...
method T (line 7206) | inline T value() const
method T (line 7211) | inline T& ref()
method T (line 7216) | inline const T& ref() const
method type (line 7221) | inline typename expression_node<T>::node_type type() const
method vector_holder_t (line 7226) | inline vector_holder_t& vec_holder()
class vector_assignment_node (line 7239) | class vector_assignment_node : public expression_node<T>
method vector_assignment_node (line 7245) | vector_assignment_node(T* vector_base,
method T (line 7266) | inline T value() const
method type (line 7296) | inline typename expression_node<T>::node_type type() const
class swap_node (line 7312) | class swap_node : public expression_node<T>
method swap_node (line 7319) | swap_node(variable_node_ptr var0, variable_node_ptr var1)
method T (line 7324) | inline T value() const
method type (line 7330) | inline typename expression_node<T>::node_type type() const
class swap_generic_node (line 7342) | class swap_generic_node : public binary_node<T>
method swap_generic_node (line 7349) | swap_generic_node(expression_ptr var0, expression_ptr var1)
method T (line 7355) | inline T value() const
method type (line 7361) | inline typename expression_node<T>::node_type type() const
class swap_vecvec_node (line 7373) | class swap_vecvec_node : public binary_node <T>,
method swap_vecvec_node (line 7382) | swap_vecvec_node(expression_ptr branch0,
method T (line 7420) | inline T value() const
method vector_node_ptr (line 7441) | vector_node_ptr vec() const
method vector_node_ptr (line 7446) | vector_node_ptr vec()
method type (line 7451) | inline typename expression_node<T>::node_type type() const
method size (line 7456) | std::size_t size() const
method vds_t (line 7461) | vds_t& vds()
method vds_t (line 7466) | const vds_t& vds() const
class stringvar_node (line 7482) | class stringvar_node : public expression_node <T>,
method stringvar_node (line 7492) | explicit stringvar_node()
method stringvar_node (line 7496) | explicit stringvar_node(std::string& v)
method T (line 7510) | inline T value() const
method str (line 7518) | std::string str() const
method char_t (line 7523) | const char_t* base() const
method size (line 7528) | std::size_t size() const
method range_t (line 7543) | range_t& range_ref()
method range_t (line 7548) | const range_t& range_ref() const
method type (line 7553) | inline typename expression_node<T>::node_type type() const
class string_range_node (line 7568) | class string_range_node : public expression_node <T>,
method string_range_node (line 7578) | explicit string_range_node(std::string& v, const range_t& rp)
method T (line 7593) | inline T value() const
method str (line 7598) | inline std::string str() const
method char_t (line 7603) | const char_t* base() const
method size (line 7608) | std::size_t size() const
method range_t (line 7613) | inline range_t range() const
method range_t (line 7628) | inline range_t& range_ref()
method range_t (line 7633) | inline const range_t& range_ref() const
method type (line 7638) | inline typename expression_node<T>::node_type type() const
class const_string_range_node (line 7653) | class const_string_range_node : public expression_node <T>,
method const_string_range_node (line 7661) | explicit const_string_range_node(const std::string& v, const range_t...
method T (line 7671) | inline T value() const
method str (line 7676) | std::string str() const
method char_t (line 7681) | const char_t* base() const
method size (line 7686) | std::size_t size() const
method range_t (line 7691) | range_t range() const
method range_t (line 7696) | range_t& range_ref()
method range_t (line 7701) | const range_t& range_ref() const
method type (line 7706) | inline typename expression_node<T>::node_type type() const
class generic_string_range_node (line 7720) | class generic_string_range_node : public expression_node <T>,
method generic_string_range_node (line 7734) | generic_string_range_node(expression_ptr str_branch, const range_t& ...
method T (line 7773) | inline T value() const
method str (line 7806) | std::string str() const
method char_t (line 7811) | const char_t* base() const
method size (line 7816) | std::size_t size() const
method range_t (line 7821) | range_t& range_ref()
method range_t (line 7826) | const range_t& range_ref() const
method type (line 7831) | inline typename expression_node<T>::node_type type() const
class string_concat_node (line 7849) | class string_concat_node : public binary_node <T>,
method string_concat_node (line 7862) | string_concat_node(const operator_type& opr,
method T (line 7910) | inline T value() const
method str (line 7945) | std::string str() const
method char_t (line 7950) | const char_t* base() const
method size (line 7955) | std::size_t size() const
method range_t (line 7960) | range_t& range_ref()
method range_t (line 7965) | const range_t& range_ref() const
method type (line 7970) | inline typename expression_node<T>::node_type type() const
class swap_string_node (line 7987) | class swap_string_node : public binary_node <T>,
method swap_string_node (line 8001) | swap_string_node(expression_ptr branch0, expression_ptr branch1)
method T (line 8020) | inline T value() const
method str (line 8033) | std::string str() const
method char_t (line 8038) | const char_t* base() const
method size (line 8043) | std::size_t size() const
method range_t (line 8048) | range_t& range_ref()
method range_t (line 8053) | const range_t& range_ref() const
method type (line 8058) | inline typename expression_node<T>::node_type type() const
class swap_genstrings_node (line 8071) | class swap_genstrings_node : public binary_node<T>
method swap_genstrings_node (line 8082) | swap_genstrings_node(expression_ptr branch0,
method T (line 8127) | inline T value() const
method type (line 8207) | inline typename expression_node<T>::node_type type() const
class stringvar_size_node (line 8225) | class stringvar_size_node : public expression_node<T>
method stringvar_size_node (line 8231) | explicit stringvar_size_node()
method stringvar_size_node (line 8235) | explicit stringvar_size_node(std::string& v)
method T (line 8239) | inline T value() const
method type (line 8244) | inline typename expression_node<T>::node_type type() const
class string_size_node (line 8258) | class string_size_node : public expression_node<T>
method string_size_node (line 8265) | string_size_node(expression_ptr brnch)
method T (line 8287) | inline T value() const
method type (line 8300) | inline typename expression_node<T>::node_type type() const
type asn_assignment (line 8312) | struct asn_assignment
method execute (line 8314) | static inline void execute(std::string& s, const char_t* data, const...
type asn_addassignment (line 8318) | struct asn_addassignment
method execute (line 8320) | static inline void execute(std::string& s, const char_t* data, const...
class assignment_string_node (line 8325) | class assignment_string_node : public binary_node <T>,
method assignment_string_node (line 8339) | assignment_string_node(const operator_type& opr,
method T (line 8377) | inline T value() const
method str (line 8401) | std::string str() const
method char_t (line 8406) | const char_t* base() const
method size (line 8411) | std::size_t size() const
method range_t (line 8416) | range_t& range_ref()
method range_t (line 8421) | const range_t& range_ref() const
method type (line 8426) | inline typename expression_node<T>::node_type type() const
class assignment_string_range_node (line 8441) | class assignment_string_range_node : public binary_node <T>,
method assignment_string_range_node (line 8455) | assignment_string_range_node(const operator_type& opr,
method T (line 8502) | inline T value() const
method str (line 8534) | std::string str() const
method char_t (line 8539) | const char_t* base() const
method size (line 8544) | std::size_t size() const
method range_t (line 8549) | range_t& range_ref()
method range_t (line 8554) | const range_t& range_ref() const
method type (line 8559) | inline typename expression_node<T>::node_type type() const
class conditional_string_node (line 8575) | class conditional_string_node : public trinary_node <T>,
method conditional_string_node (line 8588) | conditional_string_node(expression_ptr test,
method T (line 8640) | inline T value() const
method str (line 8688) | std::string str() const
method char_t (line 8693) | const char_t* base() const
method size (line 8698) | std::size_t size() const
method range_t (line 8703) | range_t& range_ref()
method range_t (line 8708) | const range_t& range_ref() const
method type (line 8713) | inline typename expression_node<T>::node_type type() const
class cons_conditional_str_node (line 8734) | class cons_conditional_str_node : public binary_node <T>,
method cons_conditional_str_node (line 8747) | cons_conditional_str_node(expression_ptr test,
method T (line 8778) | inline T value() const
method str (line 8808) | std::string str() const
method char_t (line 8813) | const char_t* base() const
method size (line 8818) | std::size_t size() const
method range_t (line 8823) | range_t& range_ref()
method range_t (line 8828) | const range_t& range_ref() const
method type (line 8833) | inline typename expression_node<T>::node_type type() const
class str_vararg_node (line 8851) | class str_vararg_node : public expression_node <T>,
method str_vararg_node (line 8866) | str_vararg_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 8930) | inline T value() const
method str (line 8942) | std::string str() const
method char_t (line 8947) | const char_t* base() const
method size (line 8952) | std::size_t size() const
method range_t (line 8957) | range_t& range_ref()
method range_t (line 8962) | const range_t& range_ref() const
method type (line 8967) | inline typename expression_node<T>::node_type type() const
function T (line 8985) | inline T axn(T a, T x)
function T (line 8992) | inline T axnb(T a, T x, T b)
type sf_base (line 8999) | struct sf_base
class sf3_node (line 9206) | class sf3_node : public trinary_node<T>
method sf3_node (line 9212) | sf3_node(const operator_type& opr,
method T (line 9219) | inline T value() const
class sf4_node (line 9230) | class sf4_node : public quaternary_node<T>
method sf4_node (line 9236) | sf4_node(const operator_type& opr,
method T (line 9244) | inline T value() const
class sf3_var_node (line 9256) | class sf3_var_node : public expression_node<T>
method sf3_var_node (line 9262) | sf3_var_node(const T& v0, const T& v1, const T& v2)
method T (line 9268) | inline T value() const
method type (line 9273) | inline typename expression_node<T>::node_type type() const
class sf4_var_node (line 9289) | class sf4_var_node : public expression_node<T>
method sf4_var_node (line 9295) | sf4_var_node(const T& v0, const T& v1, const T& v2, const T& v3)
method T (line 9302) | inline T value() const
method type (line 9307) | inline typename expression_node<T>::node_type type() const
class vararg_node (line 9324) | class vararg_node : public expression_node<T>
method vararg_node (line 9332) | vararg_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 9364) | inline T value() const
method type (line 9372) | inline typename expression_node<T>::node_type type() const
class vararg_varnode (line 9384) | class vararg_varnode : public expression_node<T>
method vararg_varnode (line 9392) | vararg_varnode(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 9411) | inline T value() const
method type (line 9419) | inline typename expression_node<T>::node_type type() const
class vectorize_node (line 9430) | class vectorize_node : public expression_node<T>
method vectorize_node (line 9436) | vectorize_node(const expression_ptr v)
method T (line 9457) | inline T value() const
method type (line 9468) | inline typename expression_node<T>::node_type type() const
class assignment_node (line 9481) | class assignment_node : public binary_node<T>
method assignment_node (line 9487) | assignment_node(const operator_type& opr,
method T (line 9499) | inline T value() const
class assignment_vec_elem_node (line 9519) | class assignment_vec_elem_node : public binary_node<T>
method assignment_vec_elem_node (line 9525) | assignment_vec_elem_node(const operator_type& opr,
method T (line 9537) | inline T value() const
class assignment_rebasevec_elem_node (line 9557) | class assignment_rebasevec_elem_node : public binary_node<T>
method assignment_rebasevec_elem_node (line 9563) | assignment_rebasevec_elem_node(const operator_type& opr,
method T (line 9575) | inline T value() const
class assignment_rebasevec_celem_node (line 9595) | class assignment_rebasevec_celem_node : public binary_node<T>
method assignment_rebasevec_celem_node (line 9601) | assignment_rebasevec_celem_node(const operator_type& opr,
method T (line 9613) | inline T value() const
class assignment_vec_node (line 9633) | class assignment_vec_node : public binary_node <T>,
method assignment_vec_node (line 9642) | assignment_vec_node(const operator_type& opr,
method T (line 9655) | inline T value() const
method vector_node_ptr (line 9713) | vector_node_ptr vec() const
method vector_node_ptr (line 9718) | vector_node_ptr vec()
method type (line 9723) | inline typename expression_node<T>::node_type type() const
method size (line 9728) | std::size_t size() const
method vds_t (line 9733) | vds_t& vds()
method vds_t (line 9738) | const vds_t& vds() const
class assignment_vecvec_node (line 9750) | class assignment_vecvec_node : public binary_node <T>,
method assignment_vecvec_node (line 9759) | assignment_vecvec_node(const operator_type& opr,
method T (line 9800) | inline T value() const
method vector_node_ptr (line 9863) | vector_node_ptr vec() const
method vector_node_ptr (line 9868) | vector_node_ptr vec()
method type (line 9873) | inline typename expression_node<T>::node_type type() const
method size (line 9878) | std::size_t size() const
method vds_t (line 9883) | vds_t& vds()
method vds_t (line 9888) | const vds_t& vds() const
class assignment_op_node (line 9903) | class assignment_op_node : public binary_node<T>
method assignment_op_node (line 9909) | assignment_op_node(const operator_type& opr,
method T (line 9921) | inline T value() const
class assignment_vec_elem_op_node (line 9940) | class assignment_vec_elem_op_node : public binary_node<T>
method assignment_vec_elem_op_node (line 9946) | assignment_vec_elem_op_node(const operator_type& opr,
method T (line 9958) | inline T value() const
class assignment_rebasevec_elem_op_node (line 9977) | class assignment_rebasevec_elem_op_node : public binary_node<T>
method assignment_rebasevec_elem_op_node (line 9983) | assignment_rebasevec_elem_op_node(const operator_type& opr,
method T (line 9995) | inline T value() const
class assignment_rebasevec_celem_op_node (line 10014) | class assignment_rebasevec_celem_op_node : public binary_node<T>
method assignment_rebasevec_celem_op_node (line 10020) | assignment_rebasevec_celem_op_node(const operator_type& opr,
method T (line 10032) | inline T value() const
class assignment_vec_op_node (line 10051) | class assignment_vec_op_node : public binary_node <T>,
method assignment_vec_op_node (line 10060) | assignment_vec_op_node(const operator_type& opr,
method T (line 10073) | inline T value() const
method vector_node_ptr (line 10132) | vector_node_ptr vec() const
method vector_node_ptr (line 10137) | vector_node_ptr vec()
method type (line 10142) | inline typename expression_node<T>::node_type type() const
method size (line 10147) | std::size_t size() const
method vds_t (line 10152) | vds_t& vds()
method vds_t (line 10157) | const vds_t& vds() const
method side_effect (line 10162) | bool side_effect() const
class assignment_vecvec_op_node (line 10174) | class assignment_vecvec_op_node : public binary_node <T>,
method assignment_vecvec_op_node (line 10183) | assignment_vecvec_op_node(const operator_type& opr,
method T (line 10218) | inline T value() const
method vector_node_ptr (line 10281) | vector_node_ptr vec() const
method vector_node_ptr (line 10286) | vector_node_ptr vec()
method type (line 10291) | inline typename expression_node<T>::node_type type() const
method size (line 10296) | std::size_t size() const
method vds_t (line 10301) | vds_t& vds()
method vds_t (line 10306) | const vds_t& vds() const
method side_effect (line 10311) | bool side_effect() const
class vec_binop_vecvec_node (line 10325) | class vec_binop_vecvec_node : public binary_node <T>,
method vec_binop_vecvec_node (line 10335) | vec_binop_vecvec_node(const operator_type& opr,
method T (line 10403) | inline T value() const
method vector_node_ptr (line 10468) | vector_node_ptr vec() const
method vector_node_ptr (line 10473) | vector_node_ptr vec()
method type (line 10478) | inline typename expression_node<T>::node_type type() const
method size (line 10483) | std::size_t size() const
method vds_t (line 10488) | vds_t& vds()
method vds_t (line 10493) | const vds_t& vds() const
class vec_binop_vecval_node (line 10509) | class vec_binop_vecval_node : public binary_node <T>,
method vec_binop_vecval_node (line 10519) | vec_binop_vecval_node(const operator_type& opr,
method T (line 10562) | inline T value() const
method vector_node_ptr (line 10625) | vector_node_ptr vec() const
method vector_node_ptr (line 10630) | vector_node_ptr vec()
method type (line 10635) | inline typename expression_node<T>::node_type type() const
method size (line 10640) | std::size_t size() const
method vds_t (line 10645) | vds_t& vds()
method vds_t (line 10650) | const vds_t& vds() const
class vec_binop_valvec_node (line 10664) | class vec_binop_valvec_node : public binary_node <T>,
method vec_binop_valvec_node (line 10674) | vec_binop_valvec_node(const operator_type& opr,
method T (line 10717) | inline T value() const
method vector_node_ptr (line 10780) | vector_node_ptr vec() const
method vector_node_ptr (line 10785) | vector_node_ptr vec()
method type (line 10790) | inline typename expression_node<T>::node_type type() const
method size (line 10795) | std::size_t size() const
method vds_t (line 10800) | vds_t& vds()
method vds_t (line 10805) | const vds_t& vds() const
class unary_vector_node (line 10819) | class unary_vector_node : public unary_node <T>,
method unary_vector_node (line 10829) | unary_vector_node(const operator_type& opr, expression_ptr branch0)
method T (line 10870) | inline T value() const
method vector_node_ptr (line 10932) | vector_node_ptr vec() const
method vector_node_ptr (line 10937) | vector_node_ptr vec()
method type (line 10942) | inline typename expression_node<T>::node_type type() const
method size (line 10947) | std::size_t size() const
method vds_t (line 10952) | vds_t& vds()
method vds_t (line 10957) | const vds_t& vds() const
class scand_node (line 10971) | class scand_node : public binary_node<T>
method scand_node (line 10977) | scand_node(const operator_type& opr,
method T (line 10983) | inline T value() const
class scor_node (line 10995) | class scor_node : public binary_node<T>
method scor_node (line 11001) | scor_node(const operator_type& opr,
method T (line 11007) | inline T value() const
class function_N_node (line 11019) | class function_N_node : public expression_node<T>
method function_N_node (line 11028) | function_N_node(ifunction* func)
method init_branches (line 11039) | bool init_branches(expression_ptr (&b)[NumBranches])
method T (line 11069) | inline T value() const
type evaluate_branches (line 11090) | struct evaluate_branches
method execute (line 11092) | static inline void execute(T_ (&v)[BranchCount], const branch_t (&...
type evaluate_branches <T_,5> (line 11102) | struct evaluate_branches <T_,5>
method execute (line 11104) | static inline void execute(T_ (&v)[5], const branch_t (&b)[5])
type evaluate_branches <T_,4> (line 11115) | struct evaluate_branches <T_,4>
method execute (line 11117) | static inline void execute(T_ (&v)[4], const branch_t (&b)[4])
type evaluate_branches <T_,3> (line 11127) | struct evaluate_branches <T_,3>
method execute (line 11129) | static inline void execute(T_ (&v)[3], const branch_t (&b)[3])
type evaluate_branches <T_,2> (line 11138) | struct evaluate_branches <T_,2>
method execute (line 11140) | static inline void execute(T_ (&v)[2], const branch_t (&b)[2])
type evaluate_branches <T_,1> (line 11148) | struct evaluate_branches <T_,1>
method execute (line 11150) | static inline void execute(T_ (&v)[1], const branch_t (&b)[1])
type invoke (line 11157) | struct invoke { static inline T execute(ifunction&, branch_t (&)[Par...
method T (line 11157) | static inline T execute(ifunction&, branch_t (&)[ParamCount]) { re...
type invoke<T_,20> (line 11160) | struct invoke<T_,20>
method T_ (line 11162) | static inline T_ execute(ifunction& f, T_ (&v)[20])
type invoke<T_,19> (line 11167) | struct invoke<T_,19>
method T_ (line 11169) | static inline T_ execute(ifunction& f, T_ (&v)[19])
type invoke<T_,18> (line 11174) | struct invoke<T_,18>
method T_ (line 11176) | static inline T_ execute(ifunction& f, T_ (&v)[18])
type invoke<T_,17> (line 11181) | struct invoke<T_,17>
method T_ (line 11183) | static inline T_ execute(ifunction& f, T_ (&v)[17])
type invoke<T_,16> (line 11188) | struct invoke<T_,16>
method T_ (line 11190) | static inline T_ execute(ifunction& f, T_ (&v)[16])
type invoke<T_,15> (line 11195) | struct invoke<T_,15>
method T_ (line 11197) | static inline T_ execute(ifunction& f, T_ (&v)[15])
type invoke<T_,14> (line 11202) | struct invoke<T_,14>
method T_ (line 11204) | static inline T_ execute(ifunction& f, T_ (&v)[14])
type invoke<T_,13> (line 11209) | struct invoke<T_,13>
method T_ (line 11211) | static inline T_ execute(ifunction& f, T_ (&v)[13])
type invoke<T_,12> (line 11216) | struct invoke<T_,12>
method T_ (line 11218) | static inline T_ execute(ifunction& f, T_ (&v)[12])
type invoke<T_,11> (line 11223) | struct invoke<T_,11>
method T_ (line 11225) | static inline T_ execute(ifunction& f, T_ (&v)[11])
type invoke<T_,10> (line 11230) | struct invoke<T_,10>
method T_ (line 11232) | static inline T_ execute(ifunction& f, T_ (&v)[10])
type invoke<T_,9> (line 11237) | struct invoke<T_,9>
method T_ (line 11239) | static inline T_ execute(ifunction& f, T_ (&v)[9])
type invoke<T_,8> (line 11244) | struct invoke<T_,8>
method T_ (line 11246) | static inline T_ execute(ifunction& f, T_ (&v)[8])
type invoke<T_,7> (line 11251) | struct invoke<T_,7>
method T_ (line 11253) | static inline T_ execute(ifunction& f, T_ (&v)[7])
type invoke<T_,6> (line 11258) | struct invoke<T_,6>
method T_ (line 11260) | static inline T_ execute(ifunction& f, T_ (&v)[6])
type invoke<T_,5> (line 11265) | struct invoke<T_,5>
method T_ (line 11267) | static inline T_ execute(ifunction& f, T_ (&v)[5])
type invoke<T_,4> (line 11272) | struct invoke<T_,4>
method T_ (line 11274) | static inline T_ execute(ifunction& f, T_ (&v)[4])
type invoke<T_,3> (line 11279) | struct invoke<T_,3>
method T_ (line 11281) | static inline T_ execute(ifunction& f, T_ (&v)[3])
type invoke<T_,2> (line 11286) | struct invoke<T_,2>
method T_ (line 11288) | static inline T_ execute(ifunction& f, T_ (&v)[2])
type invoke<T_,1> (line 11293) | struct invoke<T_,1>
method T_ (line 11295) | static inline T_ execute(ifunction& f, T_ (&v)[1])
method type (line 11299) | inline typename expression_node<T>::node_type type() const
class function_N_node<T,IFunction,0> (line 11312) | class function_N_node<T,IFunction,0> : public expression_node<T>
method function_N_node (line 11319) | function_N_node(ifunction* func)
method T (line 11328) | inline T value() const
method type (line 11336) | inline typename expression_node<T>::node_type type() const
class vararg_function_node (line 11347) | class vararg_function_node : public expression_node<T>
method vararg_function_node (line 11353) | vararg_function_node(VarArgFunction* func,
method T (line 11377) | inline T value() const
method type (line 11388) | inline typename expression_node<T>::node_type type() const
method populate_value_list (line 11395) | inline void populate_value_list() const
class generic_function_node (line 11409) | class generic_function_node : public expression_node<T>
method generic_function_node (line 11428) | generic_function_node(const std::vector<expression_ptr>& arg_list,
method init_branches (line 11439) | virtual bool init_branches()
function T (line 11529) | inline T value() const
function type (line 11544) | inline typename expression_node<T>::node_type type() const
function disable_type_checking (line 18082) | inline void disable_type_checking(Parser& p)
class results_context (line 4334) | class results_context
method results_context (line 4340) | results_context()
method count (line 4344) | inline std::size_t count() const
method type_store_t (line 4352) | inline type_store_t& operator[](const std::size_t& index)
method type_store_t (line 4357) | inline const type_store_t& operator[](const std::size_t& index) const
method clear (line 4364) | inline void clear()
method assign (line 4372) | inline void assign(const parameter_list_t& pl)
type details (line 4387) | namespace details
class return_node (line 4328) | class return_node
class return_envelope_node (line 4329) | class return_envelope_node
type operator_type (line 4389) | enum operator_type
function to_str (line 4461) | inline std::string to_str(const operator_type opr)
type base_operation_t (line 4489) | struct base_operation_t
method base_operation_t (line 4491) | base_operation_t(const operator_type t, const unsigned int& np)
type loop_unroll (line 4500) | namespace loop_unroll
type details (line 4508) | struct details
method details (line 4510) | details(const std::size_t& vsize,
function dump_ptr (line 4524) | inline void dump_ptr(const std::string& s, const void* ptr, const std:...
function dump_ptr (line 4535) | inline void dump_ptr(const std::string&, const void*) {}
function dump_ptr (line 4536) | inline void dump_ptr(const std::string&, const void*, const std::size_...
class vec_data_store (line 4540) | class vec_data_store
type control_block (line 4549) | struct control_block
method control_block (line 4551) | control_block()
method control_block (line 4558) | control_block(const std::size_t& dsize)
method control_block (line 4565) | control_block(const std::size_t& dsize, data_t dptr, bool dstrct =...
method control_block (line 4582) | static inline control_block* create(const std::size_t& dsize, data...
method destroy (line 4595) | static inline void destroy(control_block*& cntrl_blck)
method create_data (line 4621) | inline void create_data()
method vec_data_store (line 4632) | vec_data_store()
method vec_data_store (line 4636) | vec_data_store(const std::size_t& size)
method vec_data_store (line 4640) | vec_data_store(const std::size_t& size, data_t data, bool dstrct = f...
method vec_data_store (line 4644) | vec_data_store(const type& vds)
method type (line 4655) | type& operator=(const type& vds)
method data_t (line 4676) | inline data_t data()
method data_t (line 4681) | inline data_t data() const
method size (line 4686) | inline std::size_t size()
method size (line 4691) | inline std::size_t size() const
method data_t (line 4696) | inline data_t& ref()
method dump (line 4701) | inline void dump() const
method match_sizes (line 4720) | static inline void match_sizes(type& vds0, type& vds1)
method min_size (line 4729) | static inline std::size_t min_size(control_block* cb0, control_block...
type numeric (line 4743) | namespace numeric
type details (line 4745) | namespace details
function T (line 4748) | inline T process_impl(const operator_type operation, const T arg)
function T (line 4799) | inline T process_impl(const operator_type operation, const T arg0,...
function T (line 4839) | inline T process_impl(const operator_type operation, const T arg0,...
function T (line 4878) | inline T process(const operator_type operation, const T arg)
function T (line 4884) | inline T process(const operator_type operation, const T arg0, const ...
class expression_node (line 4891) | class expression_node
type node_type (line 4895) | enum node_type
method T (line 4942) | inline virtual T value() const
method node_type (line 4952) | inline virtual node_type type() const
function is_true (line 4961) | inline bool is_true(const double v)
function is_true (line 4966) | inline bool is_true(const long double v)
function is_true (line 4971) | inline bool is_true(const float v)
function is_true (line 4977) | inline bool is_true(const std::complex<T>& v)
function is_true (line 4983) | inline bool is_true(const expression_node<T>* node)
function is_false (line 4989) | inline bool is_false(const expression_node<T>* node)
function is_unary_node (line 4995) | inline bool is_unary_node(const expression_node<T>* node)
function is_neg_unary_node (line 5001) | inline bool is_neg_unary_node(const expression_node<T>* node)
function is_binary_node (line 5007) | inline bool is_binary_node(const expression_node<T>* node)
function is_variable_node (line 5013) | inline bool is_variable_node(const expression_node<T>* node)
function is_ivariable_node (line 5019) | inline bool is_ivariable_node(const expression_node<T>* node)
function is_vector_elem_node (line 5031) | inline bool is_vector_elem_node(const expression_node<T>* node)
function is_rebasevector_elem_node (line 5037) | inline bool is_rebasevector_elem_node(const expression_node<T>* node)
function is_rebasevector_celem_node (line 5043) | inline bool is_rebasevector_celem_node(const expression_node<T>* node)
function is_vector_node (line 5049) | inline bool is_vector_node(const expression_node<T>* node)
function is_ivector_node (line 5055) | inline bool is_ivector_node(const expression_node<T>* node)
function is_constant_node (line 5079) | inline bool is_constant_node(const expression_node<T>* node)
function is_null_node (line 5085) | inline bool is_null_node(const expression_node<T>* node)
function is_break_node (line 5091) | inline bool is_break_node(const expression_node<T>* node)
function is_continue_node (line 5097) | inline bool is_continue_node(const expression_node<T>* node)
function is_swap_node (line 5103) | inline bool is_swap_node(const expression_node<T>* node)
function is_function (line 5109) | inline bool is_function(const expression_node<T>* node)
function is_return_node (line 5115) | inline bool is_return_node(const expression_node<T>* node)
class unary_node (line 5120) | class unary_node
method unary_node (line 5653) | unary_node(const operator_type& opr,
method T (line 5668) | inline T value() const
method type (line 5675) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5680) | inline operator_type operation() const
method release (line 5690) | inline void release()
function is_negate_node (line 5123) | inline bool is_negate_node(const expression_node<T>* node)
function branch_deletable (line 5134) | inline bool branch_deletable(expression_node<T>* node)
function all_nodes_valid (line 5141) | inline bool all_nodes_valid(expression_node<T>* (&b)[N])
function all_nodes_valid (line 5154) | inline bool all_nodes_valid(const Sequence<expression_node<T>*,Allocat...
function all_nodes_variables (line 5165) | inline bool all_nodes_variables(expression_node<T>* (&b)[N])
function all_nodes_variables (line 5181) | inline bool all_nodes_variables(Sequence<expression_node<T>*,Allocator...
function free_all_nodes (line 5195) | inline void free_all_nodes(NodeAllocator& node_allocator, expression_n...
function free_all_nodes (line 5207) | inline void free_all_nodes(NodeAllocator& node_allocator, Sequence<exp...
function free_node (line 5218) | inline void free_node(NodeAllocator& node_allocator, expression_node<T...
function destroy_node (line 5234) | inline void destroy_node(expression_node<T>*& node)
class vector_holder (line 5241) | class vector_holder
class vector_holder_base (line 5249) | class vector_holder_base
method value_ptr (line 5255) | inline value_ptr operator[](const std::size_t& index) const
method size (line 5260) | inline std::size_t size() const
method value_ptr (line 5265) | inline value_ptr data() const
method rebaseable (line 5270) | virtual inline bool rebaseable() const
method set_ref (line 5275) | virtual void set_ref(value_ptr*) {}
class array_vector_impl (line 5283) | class array_vector_impl : public vector_holder_base
method array_vector_impl (line 5287) | array_vector_impl(const Type* vec, const std::size_t& vec_size)
method value_ptr (line 5294) | value_ptr value_at(const std::size_t& index) const
method vector_size (line 5302) | std::size_t vector_size() const
class sequence_vector_impl (line 5317) | class sequence_vector_impl : public vector_holder_base
method sequence_vector_impl (line 5323) | sequence_vector_impl(sequence_t& seq)
method value_ptr (line 5329) | value_ptr value_at(const std::size_t& index) const
method vector_size (line 5334) | std::size_t vector_size() const
class vector_view_impl (line 5346) | class vector_view_impl : public vector_holder_base
method vector_view_impl (line 5352) | vector_view_impl(vector_view_t& vec_view)
method set_ref (line 5356) | void set_ref(value_ptr* ref)
method rebaseable (line 5361) | virtual inline bool rebaseable() const
method value_ptr (line 5368) | value_ptr value_at(const std::size_t& index) const
method vector_size (line 5373) | std::size_t vector_size() const
method vector_holder (line 5389) | vector_holder(Type* vec, const std::size_t& vec_size)
method vector_holder (line 5393) | vector_holder(const vds_t& vds)
method vector_holder (line 5398) | vector_holder(std::vector<Type,Allocator>& vec)
method vector_holder (line 5402) | vector_holder(exprtk::vector_view<Type>& vec)
method value_ptr (line 5406) | inline value_ptr operator[](const std::size_t& index) const
method size (line 5411) | inline std::size_t size() const
method value_ptr (line 5416) | inline value_ptr data() const
method set_ref (line 5421) | void set_ref(value_ptr* ref)
method rebaseable (line 5426) | bool rebaseable() const
class null_node (line 5438) | class null_node : public expression_node<T>
method T (line 5442) | inline T value() const
method type (line 5447) | inline typename expression_node<T>::node_type type() const
class null_eq_node (line 5454) | class null_eq_node : public expression_node<T>
method null_eq_node (line 5460) | null_eq_node(expression_ptr brnch, const bool equality = true)
method T (line 5474) | inline T value() const
method type (line 5485) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5490) | inline operator_type operation() const
class literal_node (line 5508) | class literal_node : public expression_node<T>
method literal_node (line 5512) | explicit literal_node(const T& v)
method T (line 5516) | inline T value() const
method type (line 5521) | inline typename expression_node<T>::node_type type() const
method literal_node (line 5533) | literal_node(literal_node<T>&) {}
type range_pack (line 5540) | struct range_pack
method range_pack (line 6830) | range_pack()
method clear (line 6838) | void clear()
method free (line 6847) | void free()
method const_range (line 6876) | bool const_range()
method var_range (line 6882) | bool var_range()
method const_size (line 6932) | inline std::size_t const_size() const
method cache_size (line 6937) | inline std::size_t cache_size() const
type range_data_type (line 5543) | struct range_data_type
method range_data_type (line 6958) | range_data_type()
class range_interface (line 5546) | class range_interface
class string_base_node (line 5562) | class string_base_node
class string_literal_node (line 5579) | class string_literal_node : public expression_node <T>,
method string_literal_node (line 5587) | explicit string_literal_node(const std::string& v)
method T (line 5596) | inline T value() const
method type (line 5601) | inline typename expression_node<T>::node_type type() const
method str (line 5611) | std::string str() const
method char_t (line 5616) | const char_t* base() const
method size (line 5621) | std::size_t size() const
method range_t (line 5626) | range_t& range_ref()
method range_t (line 5631) | const range_t& range_ref() const
class unary_node (line 5647) | class unary_node : public expression_node<T>
method unary_node (line 5653) | unary_node(const operator_type& opr,
method T (line 5668) | inline T value() const
method type (line 5675) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5680) | inline operator_type operation() const
method release (line 5690) | inline void release()
type construct_branch_pair (line 5703) | struct construct_branch_pair
method process (line 5706) | static inline void process(std::pair<expression_node<T>*,bool> (&)[N...
type construct_branch_pair<T,D,true> (line 5711) | struct construct_branch_pair<T,D,true>
method process (line 5714) | static inline void process(std::pair<expression_node<T>*,bool> (&bra...
function init_branches (line 5724) | inline void init_branches(std::pair<expression_node<T>*,bool> (&branch...
type cleanup_branches (line 5748) | struct cleanup_branches
method execute (line 5751) | static inline void execute(std::pair<expression_node<T>*,bool> (&bra...
method execute (line 5765) | static inline void execute(Sequence<std::pair<expression_node<T>*,bo...
class binary_node (line 5778) | class binary_node : public expression_node<T>
method binary_node (line 5785) | binary_node(const operator_type& opr,
method T (line 5798) | inline T value() const
method type (line 5806) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5811) | inline operator_type operation()
class binary_ext_node (line 5833) | class binary_ext_node : public expression_node<T>
method binary_ext_node (line 5840) | binary_ext_node(expression_ptr branch0, expression_ptr branch1)
method T (line 5850) | inline T value() const
method type (line 5858) | inline typename expression_node<T>::node_type type() const
method operator_type (line 5863) | inline operator_type operation()
class trinary_node (line 5884) | class trinary_node : public expression_node<T>
method trinary_node (line 5891) | trinary_node(const operator_type& opr,
method T (line 5905) | inline T value() const
method type (line 5929) | inline typename expression_node<T>::node_type type() const
class quaternary_node (line 5941) | class quaternary_node : public expression_node<T>
method quaternary_node (line 5948) | quaternary_node(const operator_type& opr,
method T (line 5963) | inline T value() const
method type (line 5968) | inline typename expression_node<T>::node_type type() const
class conditional_node (line 5980) | class conditional_node : public expression_node<T>
method conditional_node (line 5986) | conditional_node(expression_ptr test,
method T (line 6015) | inline T value() const
method type (line 6023) | inline typename expression_node<T>::node_type type() const
class cons_conditional_node (line 6039) | class cons_conditional_node : public expression_node<T>
method cons_conditional_node (line 6046) | cons_conditional_node(expression_ptr test,
method T (line 6067) | inline T value() const
method type (line 6075) | inline typename expression_node<T>::node_type type() const
class break_exception (line 6090) | class break_exception
method break_exception (line 6094) | break_exception(const T& v)
class continue_exception (line 6101) | class continue_exception
class break_node (line 6105) | class break_node : public expression_node<T>
method break_node (line 6111) | break_node(expression_ptr ret = expression_ptr(0))
method T (line 6124) | inline T value() const
method type (line 6132) | inline typename expression_node<T>::node_type type() const
class continue_node (line 6144) | class continue_node : public expression_node<T>
method T (line 6148) | inline T value() const
method type (line 6156) | inline typename expression_node<T>::node_type type() const
class while_loop_node (line 6164) | class while_loop_node : public expression_node<T>
method while_loop_node (line 6170) | while_loop_node(expression_ptr condition, expression_ptr loop_body)
method T (line 6190) | inline T value() const
method type (line 6202) | inline typename expression_node<T>::node_type type() const
class repeat_until_loop_node (line 6216) | class repeat_until_loop_node : public expression_node<T>
method repeat_until_loop_node (line 6222) | repeat_until_loop_node(expression_ptr condition, expression_ptr loop...
method T (line 6242) | inline T value() const
method type (line 6255) | inline typename expression_node<T>::node_type type() const
class for_loop_node (line 6269) | class for_loop_node : public expression_node<T>
method for_loop_node (line 6275) | for_loop_node(expression_ptr initialiser,
method T (line 6312) | inline T value() const
method type (line 6338) | inline typename expression_node<T>::node_type type() const
class while_loop_bc_node (line 6357) | class while_loop_bc_node : public expression_node<T>
method while_loop_bc_node (line 6363) | while_loop_bc_node(expression_ptr condition, expression_ptr loop_body)
method T (line 6383) | inline T value() const
method type (line 6404) | inline typename expression_node<T>::node_type type() const
class repeat_until_loop_bc_node (line 6418) | class repeat_until_loop_bc_node : public expression_node<T>
method repeat_until_loop_bc_node (line 6424) | repeat_until_loop_bc_node(expression_ptr condition, expression_ptr l...
method T (line 6444) | inline T value() const
method type (line 6466) | inline typename expression_node<T>::node_type type() const
class for_loop_bc_node (line 6480) | class for_loop_bc_node : public expression_node<T>
method for_loop_bc_node (line 6486) | for_loop_bc_node(expression_ptr initialiser,
method T (line 6523) | inline T value() const
method type (line 6568) | inline typename expression_node<T>::node_type type() const
class switch_node (line 6587) | class switch_node : public expression_node<T>
method switch_node (line 6595) | switch_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 6630) | inline T value() const
method type (line 6653) | inline typename expression_node<T>::node_type type() const
class switch_n_node (line 6665) | class switch_n_node : public switch_node<T>
method switch_n_node (line 6673) | switch_n_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 6677) | inline T value() const
class multi_switch_node (line 6684) | class multi_switch_node : public expression_node<T>
method multi_switch_node (line 6692) | multi_switch_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 6727) | inline T value() const
method type (line 6752) | inline typename expression_node<T>::node_type type() const
class ivariable (line 6764) | class ivariable
class variable_node (line 6776) | class variable_node : public expression_node<T>,
method variable_node (line 6783) | explicit variable_node()
method variable_node (line 6787) | variable_node(T& v)
method T (line 6796) | inline T value() const
method T (line 6801) | inline T& ref()
method T (line 6806) | inline const T& ref() const
method type (line 6811) | inline typename expression_node<T>::node_type type() const
type range_pack (line 6825) | struct range_pack
method range_pack (line 6830) | range_pack()
method clear (line 6838) | void clear()
method free (line 6847) | void free()
method const_range (line 6876) | bool const_range()
method var_range (line 6882) | bool var_range()
method const_size (line 6932) | inline std::size_t const_size() const
method cache_size (line 6937) | inline std::size_t cache_size() const
class string_base_node (line 6950) | class string_base_node
type range_data_type (line 6953) | struct range_data_type
method range_data_type (line 6958) | range_data_type()
class vector_node (line 6973) | class vector_node
method vector_node (line 7010) | vector_node(vector_holder_t* vh)
method vector_node (line 7017) | vector_node(const vds_t& vds, vector_holder_t* vh)
method T (line 7022) | inline T value() const
method vector_node_ptr (line 7027) | vector_node_ptr vec() const
method vector_node_ptr (line 7032) | vector_node_ptr vec()
method type (line 7037) | inline typename expression_node<T>::node_type type() const
method size (line 7042) | std::size_t size() const
method vds_t (line 7047) | vds_t& vds()
method vds_t (line 7052) | const vds_t& vds() const
method vector_holder_t (line 7057) | inline vector_holder_t& vec_holder()
class vector_interface (line 6976) | class vector_interface
method side_effect (line 6996) | virtual bool side_effect () const { return false; }
class vector_node (line 7000) | class vector_node : public expression_node <T>,
method vector_node (line 7010) | vector_node(vector_holder_t* vh)
method vector_node (line 7017) | vector_node(const vds_t& vds, vector_holder_t* vh)
method T (line 7022) | inline T value() const
method vector_node_ptr (line 7027) | vector_node_ptr vec() const
method vector_node_ptr (line 7032) | vector_node_ptr vec()
method type (line 7037) | inline typename expression_node<T>::node_type type() const
method size (line 7042) | std::size_t size() const
method vds_t (line 7047) | vds_t& vds()
method vds_t (line 7052) | const vds_t& vds() const
method vector_holder_t (line 7057) | inline vector_holder_t& vec_holder()
class vector_elem_node (line 7069) | class vector_elem_node : public expression_node<T>,
method vector_elem_node (line 7078) | vector_elem_node(expression_ptr index, vector_holder_ptr vec_holder)
method T (line 7093) | inline T value() const
method T (line 7098) | inline T& ref()
method T (line 7103) | inline const T& ref() const
method type (line 7108) | inline typename expression_node<T>::node_type type() const
method vector_holder_t (line 7113) | inline vector_holder_t& vec_holder()
class rebasevector_elem_node (line 7127) | class rebasevector_elem_node : public expression_node<T>,
method rebasevector_elem_node (line 7137) | rebasevector_elem_node(expression_ptr index, vector_holder_ptr vec_h...
method T (line 7154) | inline T value() const
method T (line 7159) | inline T& ref()
method T (line 7164) | inline const T& ref() const
method type (line 7169) | inline typename expression_node<T>::node_type type() const
method vector_holder_t (line 7174) | inline vector_holder_t& vec_holder()
class rebasevector_celem_node (line 7188) | class rebasevector_celem_node : public expression_node<T>,
method rebasevector_celem_node (line 7198) | rebasevector_celem_node(const std::size_t index, vector_holder_ptr v...
method T (line 7206) | inline T value() const
method T (line 7211) | inline T& ref()
method T (line 7216) | inline const T& ref() const
method type (line 7221) | inline typename expression_node<T>::node_type type() const
method vector_holder_t (line 7226) | inline vector_holder_t& vec_holder()
class vector_assignment_node (line 7239) | class vector_assignment_node : public expression_node<T>
method vector_assignment_node (line 7245) | vector_assignment_node(T* vector_base,
method T (line 7266) | inline T value() const
method type (line 7296) | inline typename expression_node<T>::node_type type() const
class swap_node (line 7312) | class swap_node : public expression_node<T>
method swap_node (line 7319) | swap_node(variable_node_ptr var0, variable_node_ptr var1)
method T (line 7324) | inline T value() const
method type (line 7330) | inline typename expression_node<T>::node_type type() const
class swap_generic_node (line 7342) | class swap_generic_node : public binary_node<T>
method swap_generic_node (line 7349) | swap_generic_node(expression_ptr var0, expression_ptr var1)
method T (line 7355) | inline T value() const
method type (line 7361) | inline typename expression_node<T>::node_type type() const
class swap_vecvec_node (line 7373) | class swap_vecvec_node : public binary_node <T>,
method swap_vecvec_node (line 7382) | swap_vecvec_node(expression_ptr branch0,
method T (line 7420) | inline T value() const
method vector_node_ptr (line 7441) | vector_node_ptr vec() const
method vector_node_ptr (line 7446) | vector_node_ptr vec()
method type (line 7451) | inline typename expression_node<T>::node_type type() const
method size (line 7456) | std::size_t size() const
method vds_t (line 7461) | vds_t& vds()
method vds_t (line 7466) | const vds_t& vds() const
class stringvar_node (line 7482) | class stringvar_node : public expression_node <T>,
method stringvar_node (line 7492) | explicit stringvar_node()
method stringvar_node (line 7496) | explicit stringvar_node(std::string& v)
method T (line 7510) | inline T value() const
method str (line 7518) | std::string str() const
method char_t (line 7523) | const char_t* base() const
method size (line 7528) | std::size_t size() const
method range_t (line 7543) | range_t& range_ref()
method range_t (line 7548) | const range_t& range_ref() const
method type (line 7553) | inline typename expression_node<T>::node_type type() const
class string_range_node (line 7568) | class string_range_node : public expression_node <T>,
method string_range_node (line 7578) | explicit string_range_node(std::string& v, const range_t& rp)
method T (line 7593) | inline T value() const
method str (line 7598) | inline std::string str() const
method char_t (line 7603) | const char_t* base() const
method size (line 7608) | std::size_t size() const
method range_t (line 7613) | inline range_t range() const
method range_t (line 7628) | inline range_t& range_ref()
method range_t (line 7633) | inline const range_t& range_ref() const
method type (line 7638) | inline typename expression_node<T>::node_type type() const
class const_string_range_node (line 7653) | class const_string_range_node : public expression_node <T>,
method const_string_range_node (line 7661) | explicit const_string_range_node(const std::string& v, const range_t...
method T (line 7671) | inline T value() const
method str (line 7676) | std::string str() const
method char_t (line 7681) | const char_t* base() const
method size (line 7686) | std::size_t size() const
method range_t (line 7691) | range_t range() const
method range_t (line 7696) | range_t& range_ref()
method range_t (line 7701) | const range_t& range_ref() const
method type (line 7706) | inline typename expression_node<T>::node_type type() const
class generic_string_range_node (line 7720) | class generic_string_range_node : public expression_node <T>,
method generic_string_range_node (line 7734) | generic_string_range_node(expression_ptr str_branch, const range_t& ...
method T (line 7773) | inline T value() const
method str (line 7806) | std::string str() const
method char_t (line 7811) | const char_t* base() const
method size (line 7816) | std::size_t size() const
method range_t (line 7821) | range_t& range_ref()
method range_t (line 7826) | const range_t& range_ref() const
method type (line 7831) | inline typename expression_node<T>::node_type type() const
class string_concat_node (line 7849) | class string_concat_node : public binary_node <T>,
method string_concat_node (line 7862) | string_concat_node(const operator_type& opr,
method T (line 7910) | inline T value() const
method str (line 7945) | std::string str() const
method char_t (line 7950) | const char_t* base() const
method size (line 7955) | std::size_t size() const
method range_t (line 7960) | range_t& range_ref()
method range_t (line 7965) | const range_t& range_ref() const
method type (line 7970) | inline typename expression_node<T>::node_type type() const
class swap_string_node (line 7987) | class swap_string_node : public binary_node <T>,
method swap_string_node (line 8001) | swap_string_node(expression_ptr branch0, expression_ptr branch1)
method T (line 8020) | inline T value() const
method str (line 8033) | std::string str() const
method char_t (line 8038) | const char_t* base() const
method size (line 8043) | std::size_t size() const
method range_t (line 8048) | range_t& range_ref()
method range_t (line 8053) | const range_t& range_ref() const
method type (line 8058) | inline typename expression_node<T>::node_type type() const
class swap_genstrings_node (line 8071) | class swap_genstrings_node : public binary_node<T>
method swap_genstrings_node (line 8082) | swap_genstrings_node(expression_ptr branch0,
method T (line 8127) | inline T value() const
method type (line 8207) | inline typename expression_node<T>::node_type type() const
class stringvar_size_node (line 8225) | class stringvar_size_node : public expression_node<T>
method stringvar_size_node (line 8231) | explicit stringvar_size_node()
method stringvar_size_node (line 8235) | explicit stringvar_size_node(std::string& v)
method T (line 8239) | inline T value() const
method type (line 8244) | inline typename expression_node<T>::node_type type() const
class string_size_node (line 8258) | class string_size_node : public expression_node<T>
method string_size_node (line 8265) | string_size_node(expression_ptr brnch)
method T (line 8287) | inline T value() const
method type (line 8300) | inline typename expression_node<T>::node_type type() const
type asn_assignment (line 8312) | struct asn_assignment
method execute (line 8314) | static inline void execute(std::string& s, const char_t* data, const...
type asn_addassignment (line 8318) | struct asn_addassignment
method execute (line 8320) | static inline void execute(std::string& s, const char_t* data, const...
class assignment_string_node (line 8325) | class assignment_string_node : public binary_node <T>,
method assignment_string_node (line 8339) | assignment_string_node(const operator_type& opr,
method T (line 8377) | inline T value() const
method str (line 8401) | std::string str() const
method char_t (line 8406) | const char_t* base() const
method size (line 8411) | std::size_t size() const
method range_t (line 8416) | range_t& range_ref()
method range_t (line 8421) | const range_t& range_ref() const
method type (line 8426) | inline typename expression_node<T>::node_type type() const
class assignment_string_range_node (line 8441) | class assignment_string_range_node : public binary_node <T>,
method assignment_string_range_node (line 8455) | assignment_string_range_node(const operator_type& opr,
method T (line 8502) | inline T value() const
method str (line 8534) | std::string str() const
method char_t (line 8539) | const char_t* base() const
method size (line 8544) | std::size_t size() const
method range_t (line 8549) | range_t& range_ref()
method range_t (line 8554) | const range_t& range_ref() const
method type (line 8559) | inline typename expression_node<T>::node_type type() const
class conditional_string_node (line 8575) | class conditional_string_node : public trinary_node <T>,
method conditional_string_node (line 8588) | conditional_string_node(expression_ptr test,
method T (line 8640) | inline T value() const
method str (line 8688) | std::string str() const
method char_t (line 8693) | const char_t* base() const
method size (line 8698) | std::size_t size() const
method range_t (line 8703) | range_t& range_ref()
method range_t (line 8708) | const range_t& range_ref() const
method type (line 8713) | inline typename expression_node<T>::node_type type() const
class cons_conditional_str_node (line 8734) | class cons_conditional_str_node : public binary_node <T>,
method cons_conditional_str_node (line 8747) | cons_conditional_str_node(expression_ptr test,
method T (line 8778) | inline T value() const
method str (line 8808) | std::string str() const
method char_t (line 8813) | const char_t* base() const
method size (line 8818) | std::size_t size() const
method range_t (line 8823) | range_t& range_ref()
method range_t (line 8828) | const range_t& range_ref() const
method type (line 8833) | inline typename expression_node<T>::node_type type() const
class str_vararg_node (line 8851) | class str_vararg_node : public expression_node <T>,
method str_vararg_node (line 8866) | str_vararg_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 8930) | inline T value() const
method str (line 8942) | std::string str() const
method char_t (line 8947) | const char_t* base() const
method size (line 8952) | std::size_t size() const
method range_t (line 8957) | range_t& range_ref()
method range_t (line 8962) | const range_t& range_ref() const
method type (line 8967) | inline typename expression_node<T>::node_type type() const
function T (line 8985) | inline T axn(T a, T x)
function T (line 8992) | inline T axnb(T a, T x, T b)
type sf_base (line 8999) | struct sf_base
class sf3_node (line 9206) | class sf3_node : public trinary_node<T>
method sf3_node (line 9212) | sf3_node(const operator_type& opr,
method T (line 9219) | inline T value() const
class sf4_node (line 9230) | class sf4_node : public quaternary_node<T>
method sf4_node (line 9236) | sf4_node(const operator_type& opr,
method T (line 9244) | inline T value() const
class sf3_var_node (line 9256) | class sf3_var_node : public expression_node<T>
method sf3_var_node (line 9262) | sf3_var_node(const T& v0, const T& v1, const T& v2)
method T (line 9268) | inline T value() const
method type (line 9273) | inline typename expression_node<T>::node_type type() const
class sf4_var_node (line 9289) | class sf4_var_node : public expression_node<T>
method sf4_var_node (line 9295) | sf4_var_node(const T& v0, const T& v1, const T& v2, const T& v3)
method T (line 9302) | inline T value() const
method type (line 9307) | inline typename expression_node<T>::node_type type() const
class vararg_node (line 9324) | class vararg_node : public expression_node<T>
method vararg_node (line 9332) | vararg_node(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 9364) | inline T value() const
method type (line 9372) | inline typename expression_node<T>::node_type type() const
class vararg_varnode (line 9384) | class vararg_varnode : public expression_node<T>
method vararg_varnode (line 9392) | vararg_varnode(const Sequence<expression_ptr,Allocator>& arg_list)
method T (line 9411) | inline T value() const
method type (line 9419) | inline typename expression_node<T>::node_type type() const
class vectorize_node (line 9430) | class vectorize_node : public expression_node<T>
method vectorize_node (line 9436) | vectorize_node(const expression_ptr v)
method T (line 9457) | inline T value() const
method type (line 9468) | inline typename expression_node<T>::node_type type() const
class assignment_node (line 9481) | class assignment_node : public binary_node<T>
method assignment_node (line 9487) | assignment_node(const operator_type& opr,
method T (line 9499) | inline T value() const
class assignment_vec_elem_node (line 9519) | class assignment_vec_elem_node : public binary_node<T>
method assignment_vec_elem_node (line 9525) | assignment_vec_elem_node(const operator_type& opr,
method T (line 9537) | inline T value() const
class assignment_rebasevec_elem_node (line 9557) | class assignment_rebasevec_elem_node : public binary_node<T>
method assignment_rebasevec_elem_node (line 9563) | assignment_rebasevec_elem_node(const operator_type& opr,
method T (line 9575) | inline T value() const
class assignment_rebasevec_celem_node (line 9595) | class assignment_rebasevec_celem_node : public binary_node<T>
method assignment_rebasevec_celem_node (line 9601) | assignment_rebasevec_celem_node(const operator_type& opr,
method T (line 9613) | inline T value() const
class assignment_vec_node (line 9633) | class assignment_vec_node : public binary_node <T>,
method assignment_vec_node (line 9642) | assignment_vec_node(const operator_type& opr,
method T (line 9655) | inline T value() const
method vector_node_ptr (line 9713) | vector_node_ptr vec() const
method vector_node_ptr (line 9718) | vector_node_ptr vec()
method type (line 9723) | inline typename expression_node<T>::node_type type() const
method size (line 9728) | std::size_t size() const
method vds_t (line 9733) | vds_t& vds()
method vds_t (line 9738) | const vds_t& vds() const
class assignment_vecvec_node (line 9750) | class assignment_vecvec_node : public binary_node <T>,
method assignment_vecvec_node (line 9759) | assignment_vecvec_node(const operator_type& opr,
method T (line 9800) | inline T value() const
method vector_node_ptr (line 9863) | vector_node_ptr vec() const
method vector_node_ptr (line 9868) | vector_node_ptr vec()
method type (line 9873) | inline typename expression_node<T>::node_type type() const
method size (line 9878) | std::size_t size() const
method vds_t (line 9883) | vds_t& vds()
method vds_t (line 9888) | const vds_t& vds() const
class assignment_op_node (line 9903) | class assignment_op_node : public binary_node<T>
method assignment_op_node (line 9909) | assignment_op_node(const operator_type& opr,
method T (line 9921) | inline T value() const
class assignment_vec_elem_op_node (line 9940) | class assignment_vec_elem_op_node : public binary_node<T>
method assignment_vec_elem_op_node (line 9946) | assignment_vec_elem_op_node(const operator_type& opr,
method T (line 9958) | inline T value() const
class assignment_rebasevec_elem_op_node (line 9977) | class assignment_rebasevec_elem_op_node : public binary_node<T>
method assignment_rebasevec_elem_op_node (line 9983) | assignment_rebasevec_elem_op_node(const operator_type& opr,
method T (line 9995) | inline T value() const
class assignment_rebasevec_celem_op_node (line 10014) | class assignment_rebasevec_celem_op_node : public binary_node<T>
method assignment_rebasevec_celem_op_node (line 10020) | assignment_rebasevec_celem_op_node(const operator_type& opr,
method T (line 10032) | inline T value() const
class assignment_vec_op_node (line 10051) | class assignment_vec_op_node : public binary_node <T>,
method assignment_vec_op_node (line 10060) | assignment_vec_op_node(const operator_type& opr,
method T (line 10073) | inline T value() const
method vector_node_ptr (line 10132) | vector_node_ptr vec() const
method vector_node_ptr (line 10137) | vector_node_ptr vec()
method type (line 10142) | inline typename expression_node<T>::node_type type() const
method size (line 10147) | std::size_t size() const
method vds_t (line 10152) | vds_t& vds()
method vds_t (line 10157) | const vds_t& vds() const
method side_effect (line 10162) | bool side_effect() const
class assignment_vecvec_op_node (line 10174) | class assignment_vecvec_op_node : public binary_node <T>,
method assignment_vecvec_op_node (line 10183) | assignment_vecvec_op_node(const operator_type& opr,
method T (line 10218) | inline T value() const
method vector_node_ptr (line 10281) | vector_node_ptr vec() const
method vector_node_ptr (line 10286) | vector_node_ptr vec()
method type (line 10291) | inline typename expression_node<T>::node_type type() const
method size (line 10296) | std::size_t size() const
method vds_t (line 10301) | vds_t& vds()
method vds_t (line 10306) | const vds_t& vds() const
method side_effect (line 10311) | bool side_effect() const
class vec_binop_vecvec_node (line 10325) | class vec_binop_vecvec_node : public binary_node <T>,
method vec_binop_vecvec_node (line 10335) | vec_binop_vecvec_node(const operator_type& opr,
method T (line 10403) | inline T value() const
method vector_node_ptr (line 10468) | vector_node_ptr vec() const
method vector_node_ptr (line 10473) | vector_node_ptr vec()
method type (line 10478) | inline typename expression_node<T>::node_type type() const
method size (line 10483) | std::size_t size() const
method vds_t (line 10488) | vds_t& vds()
method vds_t (line 10493) | const vds_t& vds() const
class vec_binop_vecval_node (line 10509) | class vec_binop_vecval_node : public binary_node <T>,
method vec_binop_vecval_node (line 10519) | vec_binop_vecval_node(const operator_type& opr,
method T (line 10562) | inline T value() const
method vector_node_ptr (line 10625) | vector_node_ptr vec() const
method vector_node_ptr (line 10630) | vector_node_ptr vec()
method type (line 10635) | inline typename expression_node<T>::node_type type() const
method size (line 10640) | std::size_t size() const
method vds_t (line 10645) | vds_t& vds()
method vds_t (line 10650) | const vds_t& vds() const
class vec_binop_valvec_node (line 10664) | class vec_binop_valvec_node : public binary_node <T>,
method vec_binop_valvec_node (line 10674) | vec_binop_valvec_node(const operator_type& opr,
method T (line 10717) | inline T value() const
method vector_node_ptr (line 10780) | vector_node_ptr vec() const
method vector_node_ptr (line 10785) | vector_node_ptr vec()
method type (line 10790) | inline typename expression_node<T>::node_type type() const
method size (line 10795) | std::size_t size() const
method vds_t (line 10800) | vds_t& vds()
method vds_t (line 10805) | const vds_t& vds() const
class unary_vector_node (line 10819) | class unary_vector_node : public unary_node <T>,
method unary_vector_node (line 10829) | unary_vector_node(const operator_type& opr, expression_ptr branch0)
method T (line 10870) | inline T value() const
method vector_node_ptr (line 10932) | vector_node_ptr vec() const
method vector_node_ptr (line 10937) | vector_node_ptr vec()
method type (line 10942) | inline typename expression_node<T>::node_type type() const
method size (line 10947) | std::size_t size() const
method vds_t (line 10952) | vds_t& vds()
method vds_t (line 10957) | const vds_t& vds() const
class scand_node (line 10971) | class scand_node : public binary_node<T>
method scand_node (line 10977) | scand_node(const operator_type& opr,
method T (line 10983) | inline T value() const
class scor_node (line 10995) | class scor_node : public binary_node<T>
method scor_node (line 11001) | scor_node(const operator_type& opr,
method T (line 11007) | inline T value() const
class function_N_node (line 11019) | class function_N_node : public expression_node<T>
method function_N_node (line 11028) | function_N_node(ifunction* func)
method init_branches (line 11039) | bool init_branches(expression_ptr (&b)[NumBranches])
method T (line 11069) | inline T value() const
type evaluate_branches (line 11090) | struct evaluate_branches
method execute (line 11092) | static inline void execute(T_ (&v)[BranchCount], const branch_t (&...
type evaluate_branches <T_,5> (line 11102) | struct evaluate_branches <T_,5>
method execute (line 11104) | static inline void execute(T_ (&v)[5], const branch_t (&b)[5])
type evaluate_branches <T_,4> (line 11115) | struct evaluate_branches <T_,4>
method execute (line 11117) | static inline void execute(T_ (&v)[4], const branch_t (&b)[4])
type evaluate_branches <T_,3> (line 11127) | struct evaluate_branches <T_,3>
method execute (line 11129) | static inline void execute(T_ (&v)[3], const branch_t (&b)[3])
type evaluate_branches <T_,2> (line 11138) | struct evaluate_branches <T_,2>
method execute (line 11140) | static inline void execute(T_ (&v)[2], const branch_t (&b)[2])
type evaluate_branches <T_,1> (line 11148) | struct evaluate_branches <T_,1>
method execute (line 11150) | static inline void execute(T_ (&v)[1], const branch_t (&b)[1])
type invoke (line 11157) | struct invoke { static inline T execute(ifunction&, branch_t (&)[Par...
method T (line 11157) | static inline T execute(ifunction&, branch_t (&)[ParamCount]) { re...
type invoke<T_,20> (line 11160) | struct invoke<T_,20>
method T_ (line 11162) | static inline T_ execute(ifunction& f, T_ (&v)[20])
type invoke<T_,19> (line 11167) | struct invoke<T_,19>
method T_ (line 11169) | static inline T_ execute(ifunction& f, T_ (&v)[19])
type invoke<T_,18> (line 11174) | struct invoke<T_,18>
method T_ (line 11176) | static inline T_ execute(ifunction& f, T_ (&v)[18])
type invoke<T_,17> (line 11181) | struct invoke<T_,17>
method T_ (line 11183) | static inline T_ execute(ifunction& f, T_ (&v)[17])
type invoke<T_,16> (line 11188) | struct invoke<T_,16>
method T_ (line 11190) | static inline T_ execute(ifunction& f, T_ (&v)[16])
type invoke<T_,15> (line 11195) | struct invoke<T_,15>
method T_ (line 11197) | static inline T_ execute(ifunction& f, T_ (&v)[15])
type invoke<T_,14> (line 11202) | struct invoke<T_,14>
method T_ (line 11204) | static inline T_ execute(ifunction& f, T_ (&v)[14])
type invoke<T_,13> (line 11209) | struct invoke<T_,13>
method T_ (line 11211) | static inline T_ execute(ifunction& f, T_ (&v)[13])
type invoke<T_,12> (line 11216) | struct invoke<T_,12>
method T_ (line 11218) | static inline T_ execute(ifunction& f, T_ (&v)[12])
type invoke<T_,11> (line 11223) | struct invoke<T_,11>
method T_ (line 11225) | static inline T_ execute(ifunction& f, T_ (&v)[11])
type invoke<T_,10> (line 11230) | struct invoke<T_,10>
method T_ (line 11232) | static inline T_ execute(ifunction& f, T_ (&v)[10])
type invoke<T_,9> (line 11237) | struct invoke<T_,9>
method T_ (line 11239) | static inline T_ execute(ifunction& f, T_ (&v)[9])
type invoke<T_,8> (line 11244) | struct invoke<T_,8>
method T_ (line 11246) | static inline T_ execute(ifunction& f, T_ (&v)[8])
type invoke<T_,7> (line 11251) | struct invoke<T_,7>
method T_ (line 11253) | static inline T_ execute(ifunction& f, T_ (&v)[7])
type invoke<T_,6> (line 11258) | struct invoke<T_,6>
method T_ (line 11260) | static inline T_ execute(ifunction& f, T_ (&v)[6])
type invoke<T_,5> (line 11265) | struct invoke<T_,5>
method T_ (line 11267) | static inline T_ execute(ifunction& f, T_ (&v)[5])
type invoke<T_,4> (line 11272) | struct invoke<T_,4>
method T_ (line 11274) | static inline T_ execute(ifunction& f, T_ (&v)[4])
type invoke<T_,3> (line 11279) | struct invoke<T_,3>
method T_ (line 11281) | static inline T_ execute(ifunction& f, T_ (&v)[3])
type invoke<T_,2> (line 11286) | struct invoke<T_,2>
method T_ (line 11288) | static inline T_ execute(ifunction& f, T_ (&v)[2])
type invoke<T_,1> (line 11293) | struct invoke<T_,1>
method T_ (line 11295) | static inline T_ execute(ifunction& f, T_ (&v)[1])
method type (line 11299) | inline typename expression_node<T>::node_type type() const
class function_N_node<T,IFunction,0> (line 11312) | class function_N_node<T,IFunction,0> : public expression_node<T>
method function_N_node (line 11319) | function_N_node(ifunction* func)
method T (line 11328) | inline T value() const
method type (line 11336) | inline typename expression_node<T>::node_type type() const
class vararg_function_node (line 11347) | class vararg_function_node : public expression_node<T>
method vararg_function_node (line 11353) | vararg_function_node(VarArgFunction* func,
method T (line 11377) | inline T value() const
method type (line 11388) | inline typename expression_node<T>::node_type type() const
method populate_value_list (line 11395) | inline void populate_value_list() const
class generic_function_node (line 11409) | class generic_function_node : public expression_node<T>
method generic_function_node (line 11428) | generic_function_node(const std::vector<expression_ptr>& arg_list,
method init_branches (line 11439) | virtual bool init_branches()
function T (line 11529) | inline T value() const
function type (line 11544) | inline typename expression_node<T>::node_type type() const
function disable_type_checking (line 18082) | inline void disable_type_checking(Parser& p)
class string_function_node (line 11601) | class string_function_node : public generic_function_node<T,StringFuncti...
method string_function_node (line 11610) | string_function_node(StringFunction* func,
method T (line 11625) | inline T value() const
method type (line 11648) | inline typename expression_node<T>::node_type type() const
method str (line 11653) | std::string str() const
method char_t (line 11658) | const char_t* base() const
method size (line 11663) | std::size_t size() const
method range_t (line 11668) | range_t& range_ref()
method range_t (line 11673) | const range_t& range_ref() const
class multimode_genfunction_node (line 11686) | class multimode_genfunction_node : public generic_function_node<T,Generi...
method multimode_genfunction_node (line 11693) | multimode_genfunction_node(GenericFunction* func,
method T (line 11700) | inline T value() const
method type (line 11718) | inline typename expression_node<T>::node_type type() const
class multimode_strfunction_node (line 11730) | class multimode_strfunction_node : public string_function_node<T,StringF...
method multimode_strfunction_node (line 11737) | multimode_strfunction_node(StringFunction* func,
method T (line 11744) | inline T value() const
method type (line 11768) | inline typename expression_node<T>::node_type type() const
class return_exception (line 11779) | class return_exception
class null_igenfunc (line 11783) | class null_igenfunc
method T (line 11793) | inline virtual T operator() (parameter_list_t)
class return_node (line 11801) | class return_node : public generic_function_node<T,null_igenfunc<T> >
method return_node (line 11810) | return_node(const std::vector<typename gen_function_t::expression_ptr>...
method T (line 11816) | inline T value() const
method type (line 11834) | inline typename expression_node<T>::node_type type() const
class return_envelope_node (line 11845) | class return_envelope_node : public expression_node<T>
method return_envelope_node (line 11852) | return_envelope_node(expression_ptr body, results_context_t& rc)
method T (line 11867) | inline T value() const
method type (line 11883) | inline typename expression_node<T>::node_type type() const
type opr_base (line 11968) | struct opr_base
type add_op (line 11980) | struct add_op : public opr_base<T>
method T (line 11984) | static inline T process(Type t1, Type t2) { return t1 + t2; }
method T (line 11985) | static inline T process(Type t1, Type t2, Type t3) { return t1 + t2 + ...
method assign (line 11986) | static inline void assign(RefType t1, Type t2) { t1 += t2; }
method type (line 11987) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 11988) | static inline details::operator_type operation() { return details::e_a...
type mul_op (line 11992) | struct mul_op : public opr_base<T>
method T (line 11996) | static inline T process(Type t1, Type t2) { return t1 * t2; }
method T (line 11997) | static inline T process(Type t1, Type t2, Type t3) { return t1 * t2 * ...
method assign (line 11998) | static inline void assign(RefType t1, Type t2) { t1 *= t2; }
method type (line 11999) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12000) | static inline details::operator_type operation() { return details::e_m...
type sub_op (line 12004) | struct sub_op : public opr_base<T>
method T (line 12008) | static inline T process(Type t1, Type t2) { return t1 - t2; }
method T (line 12009) | static inline T process(Type t1, Type t2, Type t3) { return t1 - t2 - ...
method assign (line 12010) | static inline void assign(RefType t1, Type t2) { t1 -= t2; }
method type (line 12011) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12012) | static inline details::operator_type operation() { return details::e_s...
type div_op (line 12016) | struct div_op : public opr_base<T>
method T (line 12020) | static inline T process(Type t1, Type t2) { return t1 / t2; }
method T (line 12021) | static inline T process(Type t1, Type t2, Type t3) { return t1 / t2 / ...
method assign (line 12022) | static inline void assign(RefType t1, Type t2) { t1 /= t2; }
method type (line 12023) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12024) | static inline details::operator_type operation() { return details::e_d...
type mod_op (line 12028) | struct mod_op : public opr_base<T>
method T (line 12032) | static inline T process(Type t1, Type t2) { return numeric::modulus<T>...
method assign (line 12033) | static inline void assign(RefType t1, Type t2) { t1 = numeric::modulus...
method type (line 12034) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12035) | static inline details::operator_type operation() { return details::e_m...
type pow_op (line 12039) | struct pow_op : public opr_base<T>
method T (line 12043) | static inline T process(Type t1, Type t2) { return numeric::pow<T>(t1,...
method assign (line 12044) | static inline void assign(RefType t1, Type t2) { t1 = numeric::pow<T>(...
method type (line 12045) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12046) | static inline details::operator_type operation() { return details::e_p...
type lt_op (line 12050) | struct lt_op : public opr_base<T>
method T (line 12053) | static inline T process(Type t1, Type t2) { return ((t1 < t2) ? T(1) :...
method T (line 12054) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12055) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12056) | static inline details::operator_type operation() { return details::e_l...
type lte_op (line 12060) | struct lte_op : public opr_base<T>
method T (line 12063) | static inline T process(Type t1, Type t2) { return ((t1 <= t2) ? T(1) ...
method T (line 12064) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12065) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12066) | static inline details::operator_type operation() { return details::e_l...
type gt_op (line 12070) | struct gt_op : public opr_base<T>
method T (line 12073) | static inline T process(Type t1, Type t2) { return ((t1 > t2) ? T(1) :...
method T (line 12074) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12075) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12076) | static inline details::operator_type operation() { return details::e_g...
type gte_op (line 12080) | struct gte_op : public opr_base<T>
method T (line 12083) | static inline T process(Type t1, Type t2) { return ((t1 >= t2) ? T(1) ...
method T (line 12084) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12085) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12086) | static inline details::operator_type operation() { return details::e_g...
type eq_op (line 12090) | struct eq_op : public opr_base<T>
method T (line 12093) | static inline T process(Type t1, Type t2) { return (std::equal_to<T>()...
method T (line 12094) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12095) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12096) | static inline details::operator_type operation() { return details::e_e...
type equal_op (line 12100) | struct equal_op : public opr_base<T>
method T (line 12103) | static inline T process(Type t1, Type t2) { return numeric::equal(t1,t...
method T (line 12104) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12105) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12106) | static inline details::operator_type operation() { return details::e_e...
type ne_op (line 12110) | struct ne_op : public opr_base<T>
method T (line 12113) | static inline T process(Type t1, Type t2) { return (std::not_equal_to<...
method T (line 12114) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12115) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12116) | static inline details::operator_type operation() { return details::e_n...
type and_op (line 12120) | struct and_op : public opr_base<T>
method T (line 12123) | static inline T process(Type t1, Type t2) { return (details::is_true(t...
method type (line 12124) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12125) | static inline details::operator_type operation() { return details::e_a...
type nand_op (line 12129) | struct nand_op : public opr_base<T>
method T (line 12132) | static inline T process(Type t1, Type t2) { return (details::is_true(t...
method type (line 12133) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12134) | static inline details::operator_type operation() { return details::e_n...
type or_op (line 12138) | struct or_op : public opr_base<T>
method T (line 12141) | static inline T process(Type t1, Type t2) { return (details::is_true(t...
method type (line 12142) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12143) | static inline details::operator_type operation() { return details::e_o...
type nor_op (line 12147) | struct nor_op : public opr_base<T>
method T (line 12150) | static inline T process(Type t1, Type t2) { return (details::is_true(t...
method type (line 12151) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12152) | static inline details::operator_type operation() { return details::e_n...
type xor_op (line 12156) | struct xor_op : public opr_base<T>
method T (line 12159) | static inline T process(Type t1, Type t2) { return numeric::xor_opr<T>...
method type (line 12160) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12161) | static inline details::operator_type operation() { return details::e_x...
type xnor_op (line 12165) | struct xnor_op : public opr_base<T>
method T (line 12168) | static inline T process(Type t1, Type t2) { return numeric::xnor_opr<T...
method type (line 12169) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12170) | static inline details::operator_type operation() { return details::e_x...
type in_op (line 12174) | struct in_op : public opr_base<T>
method T (line 12177) | static inline T process(const T&, const T&) { return std::numeric_limi...
method T (line 12178) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12179) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12180) | static inline details::operator_type operation() { return details::e_i...
type like_op (line 12184) | struct like_op : public opr_base<T>
method T (line 12187) | static inline T process(const T&, const T&) { return std::numeric_limi...
method T (line 12188) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12189) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12190) | static inline details::operator_type operation() { return details::e_l...
type ilike_op (line 12194) | struct ilike_op : public opr_base<T>
method T (line 12197) | static inline T process(const T&, const T&) { return std::numeric_limi...
method T (line 12198) | static inline T process(const std::string& t1, const std::string& t2) ...
method type (line 12199) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12200) | static inline details::operator_type operation() { return details::e_i...
type inrange_op (line 12204) | struct inrange_op : public opr_base<T>
method T (line 12207) | static inline T process(const T& t0, const T& t1, const T& t2) { retur...
method T (line 12208) | static inline T process(const std::string& t0, const std::string& t1, ...
method type (line 12212) | static inline typename expression_node<T>::node_type type() { return e...
method operation (line 12213) | static inline details::operator_type operation() { return details::e_i...
function T (line 12217) | inline T value(details::expression_node<T>* n)
function T (line 12223) | inline T value(T* t)
type vararg_add_op (line 12229) | struct vararg_add_op : public opr_base<T>
method T (line 12236) | static inline T process(const Sequence<Type,Allocator>& arg_list)
method T (line 12261) | static inline T process_1(const Sequence& arg_list)
method T (line 12267) | static inline T process_2(const Sequence& arg_list)
method T (line 12273) | static inline T process_3(const Sequence& arg_list)
method T (line 12280) | static inline T process_4(const Sequence& arg_list)
method T (line 12287) | static inline T process_5(const Sequence& arg_list)
type vararg_mul_op (line 12296) | struct vararg_mul_op : public opr_base<T>
method T (line 12303) | static inline T process(const Sequence<Type,Allocator>& arg_list)
method T (line 12328) | static inline T process_1(const Sequence& arg_list)
method T (line 12334) | static inline T process_2(const Sequence& arg_list)
method T (line 12340) | static inline T process_3(const Sequence& arg_list)
method T (line 12347) | static inline T process_4(const Sequence& arg_list)
method T (line 12354) | static inline T process_5(const Sequence& arg_list)
type vararg_avg_op (line 12363) | struct vararg_avg_op : public opr_base<T>
method T (line 12370) | static inline T process(const Sequence<Type,Allocator>& arg_list)
method T (line 12385) | static inline T process_1(const Sequence& arg_list)
method T (line 12391) | static inline T process_2(const Sequence& arg_list)
method T (line 12397) | static inline T process_3(const Sequence& arg_list)
method T (line 12403) | static inline T process_4(const Sequence& arg_list)
method T (line 12410) | static inline T process_5(const Sequence& arg_list)
type vararg_min_op (line 12419) | struct vararg_min_op : public opr_base<T>
method T (line 12426) | static inline T process(const Sequence<Type,Allocator>& arg_list)
method T (line 12454) | static inline T process_1(const Sequence& arg_list)
method T (line 12460) | static inline T process_2(const Sequence& arg_list)
method T (line 12466) | static inline T process_3(const Sequence& arg_list)
method T (line 12472) | static inline T process_4(const Sequence& arg_list)
method T (line 12480) | static inline T process_5(const Sequence& arg_list)
type vararg_max_op (line 12490) | struct vararg_max_op : public opr_base<T>
method T (line 12497) | static inline T process(const Sequence<Type,Allocator>& arg_list)
method T (line 12525) | static inline T process_1(const Sequence& arg_list)
method T (line 12531) | static inline T process_2(const Sequence& arg_list)
method T (line 12537) | static inline T process_3(const Sequence& arg_list)
method T (line 12543) | static inline T process_4(const Sequence& arg_list)
method T (line 12551) | static inline T process_5(const Sequence& arg_list)
type vararg_mand_op (line 12561) | struct vararg_mand_op : public opr_base<T>
method T (line 12568) | static inline T process(const Sequence<Type,Allocator>& arg_list)
method T (line 12591) | static inline T process_1(const Sequence& arg_list)
method T (line 12598) | static inline T process_2(const Sequence& arg_list)
method T (line 12607) | static inline T process_3(const Sequence& arg_list)
method T (line 12617) | static inline T process_4(const Sequence& arg_list)
method T (line 12628) | static inline T process_5(const Sequence& arg_list)
type vararg_mor_op (line 12641) | struct vararg_mor_op : public opr_base<T>
method T (line 12648) | static inline T process(const Sequence<Type,Allocator>& arg_list)
method T (line 12671) | static inline T process_1(const Sequence& arg_list)
method T (line 12678) | static inline T process_2(const Sequence& arg_list)
method T (line 12687) | static inline T process_3(const Sequence& arg_list)
method T (line 12697) | static inline T process_4(const Sequence& arg_list)
method T (line 12708) | static inline T process_5(const Sequence& arg_list)
type vararg_multi_op (line 12721) | struct vararg_multi_op : public opr_base<T>
method T (line 12728) | static inline T process(const Sequence<Type,Allocator>& arg_list)
method T (line 12754) | static inline T process_1(const Sequence& arg_list)
method T (line 12760) | static inline T process_2(const Sequence& arg_list)
method T (line 12767) | static inline T process_3(const Sequence& arg_list)
method T (line 12775) | static inline T process_4(const Sequence& arg_list)
method T (line 12784) | static inline T process_5(const Sequence& arg_list)
method T (line 12794) | static inline T process_6(const Sequence& arg_list)
method T (line 12805) | static inline T process_7(const Sequence& arg_list)
method T (line 12817) | static inline T process_8(const Sequence& arg_list)
type vec_add_op (line 12831) | struct vec_add_op
method T (line 12835) | static inline T process(const ivector_ptr v)
type vec_mul_op (line 12932) | struct vec_mul_op
method T (line 12936) | static inline T process(const ivector_ptr v)
type vec_avg_op (line 13033) | struct vec_avg_op
method T (line 13037) | static inline T process(const ivector_ptr v)
type vec_min_op (line 13046) | struct vec_min_op
method T (line 13050) | static inline T process(const ivector_ptr v)
type vec_max_op (line 13070) | struct vec_max_op
method T (line 13074) | static inline T process(const ivector_ptr v)
class vov_base_node (line 13094) | class vov_base_node : public expression_node<T>
method operator_type (line 13101) | inline virtual operator_type operation() const
class cov_base_node (line 13112) | class cov_base_node : public expression_node<T>
method operator_type (line 13119) | inline virtual operator_type operation() const
class voc_base_node (line 13130) | class voc_base_node : public expression_node<T>
method operator_type (line 13137) | inline virtual operator_type operation() const
class vob_base_node (line 13148) | class vob_base_node : public expression_node<T>
class bov_base_node (line 13159) | class bov_base_node : public expression_node<T>
class cob_base_node (line 13170) | class cob_base_node : public expression_node<T>
method operator_type (line 13177) | inline virtual operator_type operation() const
class boc_base_node (line 13190) | class boc_base_node : public expression_node<T>
method
Condensed preview — 489 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (7,574K chars).
[
{
"path": ".clang-format",
"chars": 889,
"preview": "---\nBasedOnStyle: Microsoft\nAccessModifierOffset: '-4'\nAlignAfterOpenBracket: AlwaysBreak\nAlignConsecutiveAssignments: "
},
{
"path": ".gitattributes",
"chars": 86,
"preview": "/src/gui/license.h \n\n*.h diff=cpp\n*.c diff=cpp\n*.cpp diff=cpp\n*.rc text=auto diff=cpp\n"
},
{
"path": ".github/workflows/cmake.yml",
"chars": 6481,
"preview": "name: CMake\n\non: [push, workflow_dispatch]\n\nenv:\n # Customize the CMake build type here (Release, Debug, RelWithDebInfo"
},
{
"path": ".github/workflows/docs.yml",
"chars": 1242,
"preview": "name: Docs\n\non:\n push:\n tags:\n - '*'\n workflow_dispatch:\n\njobs:\n docs:\n runs-on: ubuntu-latest\n\n steps:"
},
{
"path": ".gitignore",
"chars": 6618,
"preview": "# Created by https://www.gitignore.io/api/visualstudio\n# Edit at https://www.gitignore.io/?templates=visualstudio\n\n### V"
},
{
"path": ".gitmodules",
"chars": 100,
"preview": "[submodule \"src/base/beehive\"]\n\tpath = src/base/beehive\n\turl = https://github.com/crust/beehive.git\n"
},
{
"path": "3rdparty/CMakeLists.txt",
"chars": 258,
"preview": "add_subdirectory(exprtk)\nadd_subdirectory(fastnoise)\nadd_subdirectory(NoesisApp)\nset_target_properties(exprtk PROPERTIES"
},
{
"path": "3rdparty/NoesisApp/CMakeLists.txt",
"chars": 3375,
"preview": "project(NoesisApp)\n\nadd_library(${PROJECT_NAME})\n\n# All used packages. Same list of packages must be added to register.c"
},
{
"path": "3rdparty/NoesisApp/README.md",
"chars": 190,
"preview": "Do NOT add the source code here. Noesis is not under a license which would allow redistribution in source code form.\n\nPr"
},
{
"path": "3rdparty/NoesisApp/pch.h",
"chars": 36,
"preview": "#pragma once\n#include <NoesisPCH.h>\n"
},
{
"path": "3rdparty/NoesisApp/register.cpp",
"chars": 2412,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////\n// NoesisGUI - http"
},
{
"path": "3rdparty/exprtk/CMakeLists.txt",
"chars": 154,
"preview": "add_library(exprtk)\n\ntarget_include_directories(exprtk\n\tPUBLIC\n\t\t${CMAKE_CURRENT_SOURCE_DIR}\n)\n\ntarget_sources(exprtk\n\tP"
},
{
"path": "3rdparty/exprtk/exprtk.cpp",
"chars": 21,
"preview": "#include \"exprtk.hpp\""
},
{
"path": "3rdparty/exprtk/exprtk.hpp",
"chars": 1376105,
"preview": "/*\n ******************************************************************\n * C++ Mathematical Expression Toolkit "
},
{
"path": "3rdparty/exprtk/license/license.json",
"chars": 1192,
"preview": "{\"Name\":\"The MIT License (MIT)\",\"Text\":\"Copyright (c) 1999 Arash Partow\\r\\n\\r\\nPermission is hereby granted, free of cha"
},
{
"path": "3rdparty/fastnoise/CMakeLists.txt",
"chars": 168,
"preview": "add_library(fastnoise)\n\ntarget_include_directories(fastnoise\n\tPUBLIC\n\t\t${CMAKE_CURRENT_SOURCE_DIR}\n)\n\ntarget_sources(fas"
},
{
"path": "3rdparty/fastnoise/FastNoise.cpp",
"chars": 108490,
"preview": "// FastNoise.cpp\r\n//\r\n// MIT License\r\n//\r\n// Copyright(c) 2017 Jordan Peck\r\n//\r\n// Permission is hereby granted, free of"
},
{
"path": "3rdparty/fastnoise/FastNoise.h",
"chars": 15047,
"preview": "// FastNoise.h\r\n//\r\n// MIT License\r\n//\r\n// Copyright(c) 2017 Jordan Peck\r\n//\r\n// Permission is hereby granted, free of c"
},
{
"path": "3rdparty/fastnoise/LICENSE",
"chars": 1067,
"preview": "MIT License\n\nCopyright (c) 2017 Jordan Peck\n\nPermission is hereby granted, free of charge, to any person obtaining a cop"
},
{
"path": "3rdparty/fastnoise/README.md",
"chars": 3753,
"preview": "# FastNoise\n\nFastNoise is an open source noise generation library with a large collection of different noise algorithms."
},
{
"path": "CMakeLists.txt",
"chars": 5144,
"preview": "cmake_minimum_required(VERSION 3.16.0)\n# Disable release-builds without debug info\nset(CMAKE_CONFIGURATION_TYPES Debug R"
},
{
"path": "Changelog.md",
"chars": 34594,
"preview": "# Changelog\nAll notable changes to this project will be documented in this file.\n\n\n## [0.8.11]\n\n### Fixed\n- traders now "
},
{
"path": "LICENSE",
"chars": 34523,
"preview": " GNU AFFERO GENERAL PUBLIC LICENSE\n Version 3, 19 November 2007\n\n Copyright (C)"
},
{
"path": "README.md",
"chars": 5473,
"preview": "# Ingnomia #\n\nJust looking for the game itself?\n\nPrebuilt binaries are available in the [release section](https://github"
},
{
"path": "cmake/modules/FindBugSplat.cmake",
"chars": 1622,
"preview": "set(BUGSPLAT_SDK_ROOT \"\" CACHE PATH \"Root to the bugsplat sdk\")\n\nfind_path(BUGSPLAT_INCLUDE_DIR\n\tNAMES\n\t\tBugSplat.h\n\tHIN"
},
{
"path": "cmake/modules/FindNoesis.cmake",
"chars": 1007,
"preview": "set(NOESIS_ROOT \"\" CACHE PATH \"Root to the NoesisGui sdk\")\n\nfind_path(NOESIS_INCLUDE_DIR\n\tNAMES\n\t\tNoesisPCH.h\n\tHINTS\n\t\t$"
},
{
"path": "cmake/modules/FindOpenAL.cmake",
"chars": 3823,
"preview": "# Distributed under the OSI-approved BSD 3-Clause License. See accompanying\n# file Copyright.txt or https://cmake.org/l"
},
{
"path": "cmake/modules/FindSteam.cmake",
"chars": 1091,
"preview": "set(STEAM_SDK_ROOT \"\" CACHE PATH \"Root to the steam sdk\")\n\nfind_path(STEAM_INCLUDE_DIR\n\tNAMES\n\t\tsteam/steam_api.h\n\tHINTS"
},
{
"path": "cmake/modules/windeployqt.cmake",
"chars": 1529,
"preview": "find_package(Qt5 REQUIRED QUIET COMPONENTS Core)\nif(TARGET Qt5::qmake AND NOT TARGET Qt5::windeployqt)\n\tget_target_prope"
},
{
"path": "content/CMakeLists.txt",
"chars": 443,
"preview": "file(\n\tGLOB_RECURSE SOURCE_LIST\n\tRELATIVE ${CMAKE_CURRENT_SOURCE_DIR}\n\t\"*.xml\"\n\t\"*.json\"\n\t\"*.glsl\"\n\t\"*.xaml\"\n\t\"*.ttf\"\n\t\""
},
{
"path": "content/JSON/config.json",
"chars": 1085,
"preview": "{\n \"AutoSaveInterval\": 3,\n \"CurrentVersion\": \"0.7.5.0\",\n \"DaysToNextAutoSave\": 1,\n \"GUIScale\": 1.0,\n \"Las"
},
{
"path": "content/JSON/embarkpresets.json",
"chars": 5466,
"preview": "[\r\n{\r\n\t\"Name\": \"Gnomoria\",\r\n\t\"startingItems\": [{\r\n\t\t\t\"Amount\": 2,\r\n\t\t\t\"Components\": [{\r\n\t\t\t\t\t\"ItemID\": \"PickaxeHead\",\r\n\t"
},
{
"path": "content/JSON/menusettings.json",
"chars": 10096,
"preview": "[\r\n {\r\n\t\"Text\": \"Terrain\",\r\n\t\"Icon\": \":/resources/icons/terrain.png\",\r\n\t\"MenuItem\": [\r\n\t {\r\n\t\t\"Text\": \"Mine\",\r\n\t\t\"Icon"
},
{
"path": "content/JSON/newgame.json",
"chars": 3137,
"preview": "{\n \"allowedAnimals\": {\n \"Badger\": 2,\n \"Beetle\": 0,\n \"BeetleEgg\": 0,\n \"BlackBear\": 2,\n "
},
{
"path": "content/JSON/profs.json",
"chars": 1209,
"preview": "[\n\t{\n \"Name\": \"Gnomad\",\n \"Skills\": [\n\t\t\t\"Mining\",\n\t\t\t\"Masonry\",\n\t\t\t\"Stonecarving\",\n\t\t\t\"Woodcutting\",\n\t\t\t\"C"
},
{
"path": "content/ai/animal_big.xml",
"chars": 2687,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/animal_guard_dog.xml",
"chars": 2042,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/animal_hunter.xml",
"chars": 1967,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/animal_nighthunter.xml",
"chars": 2342,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/animal_small_pasture.xml",
"chars": 2403,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/animal_standard.xml",
"chars": 3417,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/automaton_mark1.xml",
"chars": 14714,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"Combat\">"
},
{
"path": "content/ai/automaton_mark2.xml",
"chars": 14714,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"Combat\">"
},
{
"path": "content/ai/egg.xml",
"chars": 2630,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/gnome_standard.xml",
"chars": 17314,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"AlarmTre"
},
{
"path": "content/ai/gnome_trader.xml",
"chars": 5526,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"Hunger\">"
},
{
"path": "content/ai/monster_mant_queen.xml",
"chars": 1044,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/monster_mant_soldier.xml",
"chars": 1044,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/monster_mant_worker.xml",
"chars": 1044,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/ai/monster_standard.xml",
"chars": 1044,
"preview": "<root main_tree_to_execute=\"MainTree\">\n <!-- =================================== -->\n <BehaviorTree ID=\"MainTree"
},
{
"path": "content/db/ingnomia.db.sql",
"chars": 2049064,
"preview": "BEGIN TRANSACTION;\r\nDROP TABLE IF EXISTS \"Workshops_Components\";\r\nCREATE TABLE IF NOT EXISTS \"Workshops_Components\" (\r\n\t"
},
{
"path": "content/shaders/axle_f.glsl",
"chars": 1386,
"preview": "#version 430 core\r\n\r\nlayout(location = 0) noperspective in vec2 vTexCoords;\r\n\r\nlayout(location = 0) out vec4 fColor;\r\n\r\n"
},
{
"path": "content/shaders/axle_v.glsl",
"chars": 1432,
"preview": "#version 430 core\r\n\r\nlayout(location = 0) in vec3 aPos;\r\n\r\nlayout(location = 0) noperspective out vec2 vTexCoords;\r\n\r\nun"
},
{
"path": "content/shaders/selection_f.glsl",
"chars": 1457,
"preview": "#version 430 core\r\n\r\nlayout(location = 0) noperspective in vec2 vTexCoords;\r\n\r\nlayout(location = 0) out vec4 fColor;\r\n\r\n"
},
{
"path": "content/shaders/selection_v.glsl",
"chars": 1432,
"preview": "#version 430 core\r\n\r\nlayout(location = 0) in vec3 aPos;\r\n\r\nlayout(location = 0) noperspective out vec2 vTexCoords;\r\n\r\nun"
},
{
"path": "content/shaders/thoughtbubble_f.glsl",
"chars": 358,
"preview": "#version 430 core\r\n\r\nlayout(location = 0) noperspective in vec2 vTexCoords;\r\n\r\nlayout(location = 0) out vec4 fColor;\r\n\r\n"
},
{
"path": "content/shaders/thoughtbubble_v.glsl",
"chars": 1513,
"preview": "#version 430 core\r\n\r\nlayout(location = 0) in vec3 aPos;\r\n\r\nlayout(location = 0) noperspective out vec2 vTexCoords;\r\n\r\nun"
},
{
"path": "content/shaders/world_f.glsl",
"chars": 12810,
"preview": "#version 430 core\r\n\r\n#define TF_NONE 0x00000000u\r\n#define TF_WALKABLE 0x00000001u\r\n#define T"
},
{
"path": "content/shaders/world_v.glsl",
"chars": 8935,
"preview": "#version 430 core\r\n\r\n#define TF_NONE 0x00000000u\r\n#define TF_WALKABLE 0x00000001u\r\n#define T"
},
{
"path": "content/shaders/worldupdate_c.glsl",
"chars": 925,
"preview": "#version 430 core\n\n// DO NOT CHANGE, must match game internal layout\nstruct TileData {\n\t// TF_ flags 0:32\n\tuint flags;\n\t"
},
{
"path": "content/xaml/Agriculture.xaml",
"chars": 15012,
"preview": "<UserControl\n\tx:Class=\"IngnomiaGUI.Agriculture\"\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n\txmln"
},
{
"path": "content/xaml/CreatureInfo.xaml",
"chars": 12321,
"preview": "<UserControl\n\tx:Class=\"IngnomiaGUI.CreatureInfo\"\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n\txml"
},
{
"path": "content/xaml/DebugGui.xaml",
"chars": 4947,
"preview": "<UserControl\n\tx:Class=\"IngnomiaGUI.DebugGui\"\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n\txmlns:x"
},
{
"path": "content/xaml/Fonts/SIL Open Font License.txt",
"chars": 4475,
"preview": "Copyright (c) 2009 - 2014 Grand Chaos Productions (http://grandchaos9000.deviantart.com), with Reserved Font Name 8-bit "
},
{
"path": "content/xaml/GameGui.xaml",
"chars": 18894,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.GameGui\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txmlns"
},
{
"path": "content/xaml/IngamePage.xaml",
"chars": 3057,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.IngamePage\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\tx"
},
{
"path": "content/xaml/InventoryGui.xaml",
"chars": 2257,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.InventoryGui\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\t"
},
{
"path": "content/xaml/LoadGamePage.xaml",
"chars": 3758,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.LoadGamePage\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n"
},
{
"path": "content/xaml/Main.xaml",
"chars": 1793,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.Main\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txmlns:x="
},
{
"path": "content/xaml/MainMenu.xaml",
"chars": 4568,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.MainMenu\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txml"
},
{
"path": "content/xaml/MainPage.xaml",
"chars": 4351,
"preview": "<UserControl\n\tx:Class=\"IngnomiaGUI.MainPage\"\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n\txmlns:"
},
{
"path": "content/xaml/MilitaryGui.xaml",
"chars": 5753,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.MilitaryGui\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\tx"
},
{
"path": "content/xaml/Neighbors.xaml",
"chars": 7708,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.NeighborsGui\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\t"
},
{
"path": "content/xaml/NewGamePage.xaml",
"chars": 23538,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.NewGamePage\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\t"
},
{
"path": "content/xaml/PopulationWindow.xaml",
"chars": 13268,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.PopulationWindow\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation"
},
{
"path": "content/xaml/SelectionGui.xaml",
"chars": 1481,
"preview": "<UserControl\n\tx:Class=\"IngnomiaGUI.SelectionGui\"\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n\txml"
},
{
"path": "content/xaml/SettingsPage.xaml",
"chars": 8802,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.SettingsPage\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n"
},
{
"path": "content/xaml/StockpileGui.xaml",
"chars": 8357,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.StockpileGui\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\t"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkAqua.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkBlue.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkCrimson.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkEmerald.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkGreen.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkLime.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkOrange.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkPurple.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.DarkRed.xaml",
"chars": 5945,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightAqua.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightBlue.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightCrimson.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightEmerald.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightGreen.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightLime.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightOrange.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightPurple.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Brushes.LightRed.xaml",
"chars": 5946,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Colors.Dark.xaml",
"chars": 752,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.Colors.Light.xaml",
"chars": 752,
"preview": "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkAqua.xaml",
"chars": 519,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkBlue.xaml",
"chars": 519,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkCrimson.xaml",
"chars": 522,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkEmerald.xaml",
"chars": 522,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkGreen.xaml",
"chars": 520,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkLime.xaml",
"chars": 519,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkOrange.xaml",
"chars": 521,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkPurple.xaml",
"chars": 521,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.DarkRed.xaml",
"chars": 518,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.Fonts.xaml",
"chars": 476,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightAqua.xaml",
"chars": 520,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightBlue.xaml",
"chars": 520,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightCrimson.xaml",
"chars": 523,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightEmerald.xaml",
"chars": 523,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightGreen.xaml",
"chars": 521,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightLime.xaml",
"chars": 520,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightOrange.xaml",
"chars": 522,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightPurple.xaml",
"chars": 522,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.LightRed.xaml",
"chars": 519,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.m"
},
{
"path": "content/xaml/Theme/NoesisTheme.Styles.xaml",
"chars": 190330,
"preview": "<ResourceDictionary\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n xmlns:x=\"http://schemas.micro"
},
{
"path": "content/xaml/TileInfo.xaml",
"chars": 14289,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.TileInfo\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txmln"
},
{
"path": "content/xaml/WaitPage.xaml",
"chars": 2042,
"preview": "<UserControl\r\n\tx:Class=\"IngnomiaGUI.WaitPage\"\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txml"
},
{
"path": "content/xaml/WorkshopGui.xaml",
"chars": 21727,
"preview": "<UserControl\n\tx:Class=\"IngnomiaGUI.WorkshopGui\"\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n\txmln"
},
{
"path": "content/xaml/localization/_.xaml",
"chars": 22323,
"preview": "<ResourceDictionary\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txmlns:x=\"http://schemas.micros"
},
{
"path": "content/xaml/localization/en_US.xaml",
"chars": 20535,
"preview": "<ResourceDictionary\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txmlns:x=\"http://schemas.micros"
},
{
"path": "content/xaml/localization/fr_FR.xaml",
"chars": 20592,
"preview": "<ResourceDictionary\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txmlns:x=\"http://schemas.micros"
},
{
"path": "content/xaml/localization/pt_BR.xaml",
"chars": 20771,
"preview": "<ResourceDictionary\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txmlns:x=\"http://schemas.micros"
},
{
"path": "content/xaml/styles/colors.xaml",
"chars": 6537,
"preview": "<ResourceDictionary\r\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\" \r\n xmlns:x=\"http://schemas"
},
{
"path": "content/xaml/styles/mainmenu/pageswap.xaml",
"chars": 6593,
"preview": "<ResourceDictionary\r\n xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\" \r\n xmlns:x=\"http://schemas"
},
{
"path": "content/xaml/styles/mainmenu/styles.xaml",
"chars": 62830,
"preview": "<ResourceDictionary\r\n\txmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\r\n\txmlns:x=\"http://schemas.micro"
},
{
"path": "devmessages.txt",
"chars": 347,
"preview": "Welcome to Ingnomia.\r\n\r\nThis game is still under heavy development.\r\n\r\nPlease report any bugs you find using the in game"
},
{
"path": "docs/Pipfile",
"chars": 151,
"preview": "[[source]]\nurl = \"https://pypi.org/simple\"\nverify_ssl = true\nname = \"pypi\"\n\n[packages]\njinja2 = \"*\"\n\n[dev-packages]\n\n[re"
},
{
"path": "docs/generate.py",
"chars": 938,
"preview": "#!/usr/bin/env python3\n\nimport argparse\nimport os\nimport sys\n\nfrom lib.util import DOCDIR\nfrom lib.render import render\n"
},
{
"path": "docs/lib/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "docs/lib/db.py",
"chars": 11606,
"preview": "import os\nimport sqlite3\n\nfrom .util import DOCDIR, empty, log\n\nDB_PATH = os.path.join(DOCDIR, \"..\", \"content\", \"db\", \"i"
},
{
"path": "docs/lib/material.py",
"chars": 1924,
"preview": "from .db import db\nfrom .util import empty\n\n\nclass MaterialSet:\n colors = {id: color for (id, color) in db.materials("
},
{
"path": "docs/lib/render.py",
"chars": 239,
"preview": "from .themes import themes\n\n\ndef render(theme, output, build_id):\n try:\n ThemeCtor = themes[theme]\n except "
},
{
"path": "docs/lib/sprites/__init__.py",
"chars": 79,
"preview": "from .sprite import SpriteManager, MissingMaterials\nfrom .layout import Layout\n"
},
{
"path": "docs/lib/sprites/layout.py",
"chars": 6747,
"preview": "import random\n\nfrom ..db import db\nfrom ..util import empty, sprite_offset3d\nfrom .sprite import EmptySprite, Sprite, Sp"
},
{
"path": "docs/lib/sprites/render.py",
"chars": 4711,
"preview": "from ..db import db\nfrom ..util import empty\n\ncolors = {mat: color for (mat, color) in db.materials()}\n\n\nclass RenderBas"
},
{
"path": "docs/lib/sprites/sprite.py",
"chars": 10075,
"preview": "from random import choice\n\nfrom ..db import db\nfrom ..util import empty, log, sprite_offset, sprite_rect\n\nfrom .render i"
},
{
"path": "docs/lib/store.py",
"chars": 16013,
"preview": "from .db import db\nfrom .material import MaterialSet\nfrom .util import empty, log, sort_translations, total_amount, amou"
},
{
"path": "docs/lib/themes/__init__.py",
"chars": 76,
"preview": "from .default.theme import DefaultTheme\n\nthemes = {\"default\": DefaultTheme}\n"
},
{
"path": "docs/lib/themes/default/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "docs/lib/themes/default/assets/doc.js",
"chars": 2696,
"preview": "function setupSearch() {\n let input = document.querySelector('input[type=\"search\"]')\n let queryDisplay = document.quer"
},
{
"path": "docs/lib/themes/default/assets/style.css",
"chars": 4173,
"preview": "/* Global styles */\n\n:root {\n --color-fade: #888;\n --color-text: #444;\n --color-hover: #111;\n --color-bg: #eee;\n --"
},
{
"path": "docs/lib/themes/default/sprites.py",
"chars": 12673,
"preview": "from collections import defaultdict\n\nfrom ...sprites import SpriteManager, MissingMaterials, Layout\nfrom ...util import "
},
{
"path": "docs/lib/themes/default/templates/base.html.j2",
"chars": 1539,
"preview": "<!DOCTYPE html>\n{% import \"macros.html.j2\" as macros with context %}\n<head>\n <title>{% block title %}Ingnomia docs{% en"
},
{
"path": "docs/lib/themes/default/templates/constructions.html.j2",
"chars": 258,
"preview": "{% extends \"base.html.j2\" %}\n{% import \"macros.html.j2\" as macros with context %}\n\n{% block title %}\n All Constructions"
},
{
"path": "docs/lib/themes/default/templates/food.html.j2",
"chars": 1325,
"preview": "{% extends \"base.html.j2\" %}\n{% import \"macros.html.j2\" as macros with context %}\n\n\n{% macro food_table(data, value_labe"
},
{
"path": "docs/lib/themes/default/templates/index.html.j2",
"chars": 182,
"preview": "{% extends \"base.html.j2\" %}\n\n{% block content %}\n <h2>Auto-generated documentation for Ingnomia</h2>\n\n Use the menu, "
},
{
"path": "docs/lib/themes/default/templates/item.html.j2",
"chars": 3698,
"preview": "{% extends \"base.html.j2\" %}\n{% import \"macros.html.j2\" as macros with context %}\n\n{% block title %}\n {{ item.translati"
},
{
"path": "docs/lib/themes/default/templates/items.html.j2",
"chars": 258,
"preview": "{% extends \"base.html.j2\" %}\n{% import \"macros.html.j2\" as macros with context %}\n\n{% block title %}\n All Items - {{ su"
},
{
"path": "docs/lib/themes/default/templates/macros.html.j2",
"chars": 6434,
"preview": "{% macro spritelayout(rendered, type, id, matset='any', zoom=False) %}\n <span class=\"\n layout\n l-{{ rendered.bbox"
},
{
"path": "docs/lib/themes/default/templates/navtable.html.j2",
"chars": 78,
"preview": "{% import \"macros.html.j2\" as macros with context %}\n{{ macros.nav_table() }}\n"
},
{
"path": "docs/lib/themes/default/templates/plants.html.j2",
"chars": 1731,
"preview": "{% extends \"base.html.j2\" %}\n{% import \"macros.html.j2\" as macros with context %}\n\n{% block title %}\n All Plants - {{ s"
},
{
"path": "docs/lib/themes/default/templates/sprites.css.j2",
"chars": 1054,
"preview": ".zoomed .cells {\n position: absolute;\n transform: translate(-50%, -50%) scale(2, 2) translate(50%, 50%);\n}\n\n.layout {\n"
},
{
"path": "docs/lib/themes/default/templates/tints.svg.j2",
"chars": 440,
"preview": "<svg xmlns=\"http://www.w3.org/2000/svg\">\n {% for tint in tints %}\n <filter id=\"{{ tint.id }}\" color-interpolation-fi"
},
{
"path": "docs/lib/themes/default/templates/workshop.html.j2",
"chars": 1117,
"preview": "{% extends \"base.html.j2\" %}\n{% import \"macros.html.j2\" as macros with context %}\n\n{% block title %}\n {{ workshop.trans"
},
{
"path": "docs/lib/themes/default/templates/workshops.html.j2",
"chars": 293,
"preview": "{% extends \"base.html.j2\" %}\n{% import \"macros.html.j2\" as macros with context %}\n\n{% block title %}\n All Workshops - {"
},
{
"path": "docs/lib/themes/default/theme.py",
"chars": 8682,
"preview": "from datetime import datetime\nimport os\nimport shutil\nfrom jinja2 import Environment, FileSystemLoader\n\nfrom ...store im"
},
{
"path": "docs/lib/util.py",
"chars": 1795,
"preview": "import os\n\nDOCDIR = os.path.realpath(os.path.dirname(os.path.dirname(__file__)))\n\n\ndef empty(value):\n return value is"
},
{
"path": "gui/SampleData/GameModelSampleData.xaml",
"chars": 8506,
"preview": "<IngnomiaGUI:GameModel xmlns:IngnomiaGUI=\"clr-namespace:IngnomiaGUI\"\n Day=\"Cras nam aenean class\""
},
{
"path": "gui/SampleData/StockpileModelSampleData.xaml",
"chars": 1124,
"preview": "<IngnomiaGUI:StockpileModel xmlns:IngnomiaGUI=\"clr-namespace:IngnomiaGUI\" Name=\"Cras vestibulum\" PullFromHere=\"False\" P"
},
{
"path": "gui/SampleData/ViewModelSampleData.xaml",
"chars": 381,
"preview": "<IngnomiaGUI:ViewModel xmlns:IngnomiaGUI=\"clr-namespace:IngnomiaGUI\"\n Platform=\"Aliquam aenean ve"
},
{
"path": "gui/Src/App.config",
"chars": 180,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<configuration>\n <startup> \n <supportedRuntime version=\"v4.0\" sku=\".NET"
},
{
"path": "gui/Src/Properties/AssemblyInfo.cs",
"chars": 1818,
"preview": "using System.Reflection;\nusing System.Resources;\nusing System.Runtime.CompilerServices;\nusing System.Runtime.InteropSer"
},
{
"path": "gui/Src/stubs.cs",
"chars": 5245,
"preview": "using System.Windows.Controls;\r\nusing System.Collections.Generic;\r\n\r\nnamespace IngnomiaGUI\r\n{\r\n public enum State\r\n "
},
{
"path": "gui/app.config",
"chars": 158,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<configuration>\n<startup><supportedRuntime version=\"v4.0\" sku=\".NETFramework,Vers"
},
{
"path": "gui/gui.csproj",
"chars": 5336,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Project ToolsVersion=\"14.0\" DefaultTargets=\"Build\" xmlns=\"http://schemas.micro"
},
{
"path": "keybindings.json",
"chars": 37134,
"preview": "[\n {\n \"GroupName\": \"Navigation\",\n \"Keys\": [\n {\n \"Command\": \"WorldScrollLeft\","
},
{
"path": "src/CMakeLists.txt",
"chars": 208,
"preview": "file(GLOB_RECURSE SOURCE_LIST\n\t\"*.h\"\n\t\"*.hpp\"\n\t\"*.cpp\"\n)\n\ntarget_sources(${PROJECT_NAME}\n\tPRIVATE\n\t\t${SOURCE_LIST}\n\t\t${C"
},
{
"path": "src/base/PathFinderThread.cpp",
"chars": 7637,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/PathFinderThread.h",
"chars": 2575,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_factory.cpp",
"chars": 5814,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_factory.h",
"chars": 1727,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_node.cpp",
"chars": 4856,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_node.h",
"chars": 2204,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeaction.cpp",
"chars": 1305,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeaction.h",
"chars": 1826,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodebbprecondition.cpp",
"chars": 1365,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodebbprecondition.h",
"chars": 1133,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeconditional.cpp",
"chars": 1341,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeconditional.h",
"chars": 1841,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodefallback.cpp",
"chars": 1714,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodefallback.h",
"chars": 1033,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodefallbackstar.cpp",
"chars": 1860,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodefallbackstar.h",
"chars": 1045,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeforcefailure.cpp",
"chars": 1271,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeforcefailure.h",
"chars": 1031,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeforcesuccess.cpp",
"chars": 1271,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeforcesuccess.h",
"chars": 1031,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeinverter.cpp",
"chars": 1409,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodeinverter.h",
"chars": 1033,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_noderepeat.cpp",
"chars": 2797,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_noderepeat.h",
"chars": 1132,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_noderepeatuntilsuccess.cpp",
"chars": 2895,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_noderepeatuntilsuccess.h",
"chars": 1168,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodesequence.cpp",
"chars": 1714,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodesequence.h",
"chars": 1033,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodesequencestar.cpp",
"chars": 3363,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
},
{
"path": "src/base/behaviortree/bt_nodesequencestar.h",
"chars": 1177,
"preview": "/*\t\r\n\tThis file is part of Ingnomia https://github.com/rschurade/Ingnomia\r\n Copyright (C) 2017-2020 Ralph Schurade, "
}
]
// ... and 289 more files (download for full content)
About this extraction
This page contains the full source code of the rschurade/Ingnomia GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 489 files (6.6 MB), approximately 1.7M tokens, and a symbol index with 4061 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.