diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000..50361afbf6 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +docs/changelog.txt merge=union diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 0000000000..2367db6786 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,6 @@ +Thank you for your interest in contributing to DFHack! If you're reading this +document, you're probably viewing it on GitHub. The DFHack docs are hosted +on [ReadTheDocs](https://dfhack.readthedocs.io/) - in particular, contributing +guidelines are [here](https://docs.dfhack.org/en/latest/docs/Contributing.html). +Double-checking the style guidelines before submitting a pull request is +always appreciated. diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000000..e68a754c63 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1 @@ +If this PR makes an externally-visible change in behavior or API, please add an appropriate line to `docs/changelog.txt`. diff --git a/.github/release_template.md b/.github/release_template.md new file mode 100644 index 0000000000..2bfc7a3c04 --- /dev/null +++ b/.github/release_template.md @@ -0,0 +1,64 @@ +#### Q: How do I download DFHack? +**A:** Either add to your Steam library from our [Steam page](https://store.steampowered.com/app/2346660/DFHack) or scroll to the latest release on our [GitHub releases page](https://github.com/DFHack/dfhack/releases), expand the "Assets" list, and download the file for your platform (e.g. `dfhack-XX.XX-rX-Windows-64bit.zip`. If you are on Windows and are manually installing from the zip file, please remember to right click on the file after downloading, open the file properties, and select the "Unblock" checkbox. This will prevent issues with Windows antivirus programs. + +------------- + +This release is compatible with all distributions of Dwarf Fortress: [Steam](https://store.steampowered.com/app/975370/Dwarf_Fortress/), [Itch](https://kitfoxgames.itch.io/dwarf-fortress), and [Classic](https://www.bay12games.com/dwarves/). + +- [Install DFHack from Steam](https://store.steampowered.com/app/2346660/DFHack) +- [Manual install](https://docs.dfhack.org/en/stable/docs/Installing.html#installing) +- [Quickstart guide (for players)](https://docs.dfhack.org/en/stable/docs/Quickstart.html#quickstart) +- [Modding guide (for modders)](https://docs.dfhack.org/en/stable/docs/guides/modding-guide.html) + +Please report any issues (or feature requests) on the DFHack [GitHub issue tracker](https://github.com/DFHack/dfhack/issues). When reporting issues, please upload a zip file of your savegame and a zip file of your `mods` directory to the cloud and add links to the GitHub issue. Make sure your files are downloadable by "everyone with the link". We need your savegame to reproduce the problem and test the fix, and we need your active mods so we can load your savegame. Issues with savegames and mods attached get fixed first! + +Highlights +---------------------------------- + +
+Highlight 1, Highlight 2 + +### Highlight 1 + +Demo screenshot/vidcap + +Text + +### Highlight 2 + +Demo screenshot/vidcap + +Text + +
+ +Announcements +---------------------------------- + +
+Annc 1, PSAs + +### Annc 1 + +Text + +### PSAs + +As always, remember that, just like the vanilla DF game, DFHack tools can also have bugs. It is a good idea to **save often and keep backups** of the forts that you care about. + +Some DFHack tools that worked in previous (pre-Steam) versions of DF have not been updated yet and are marked with the "unavailable" tag in their docs. If you try to run them, they will show a warning and exit immediately. You can run the command again to override the warning (though of course the tools may not work). We make no guarantees of reliability for the tools that are marked as "unavailable". + +The in-game interface for running DFHack commands (`gui/launcher`) will not show "unavailable" tools by default. You can still run them if you know their names, or you can turn on dev mode by hitting Ctrl-D while in `gui/launcher` and they will be added to the autocomplete list. Some tools listed as "unavailable" in the docs do not compile yet and are not accessible at all, even when in dev mode. + +If you see a tool complaining about the lack of a cursor, know that it's referring to the **keyboard** cursor (which used to be the only real option in Dwarf Fortress). You can enable the keyboard cursor by entering mining mode or selecting the dump/forbid tool and hitting Alt-K (the DFHack keybinding for `toggle-kbd-cursor`). We're working on making DFHack tools more mouse-aware and accessible so this step isn't necessary in the future. + +
+ +Changelog +==================== + +
+New tools, fixes, and improvements + +%RELEASE_NOTES% +
diff --git a/.github/workflows/build-linux.yml b/.github/workflows/build-linux.yml new file mode 100644 index 0000000000..c2d946e300 --- /dev/null +++ b/.github/workflows/build-linux.yml @@ -0,0 +1,205 @@ +name: Build linux64 + +on: + workflow_call: + inputs: + dfhack_repo: + type: string + default: DFHack/dfhack + dfhack_ref: + type: string + scripts_repo: + type: string + default: DFHack/scripts + scripts_ref: + type: string + structures_repo: + type: string + default: DFHack/df-structures + structures_ref: + type: string + stonesense_repo: + type: string + default: DFHack/stonesense + stonesense_ref: + type: string + artifact-name: + type: string + append-date-and-hash: + type: boolean + default: false + cache-id: + type: string + default: '' + cache-readonly: + type: boolean + default: false + platform-files: + type: boolean + default: true + plugins: + type: boolean + default: true + common-files: + type: boolean + default: true + docs: + type: boolean + default: false + html: + type: boolean + default: true + stonesense: + type: boolean + default: false + launchdf: + type: boolean + default: false + extras: + type: boolean + default: false + tests: + type: boolean + default: false + xml-dump-type-sizes: + type: boolean + default: false + gcc-ver: + type: string + default: "11" + +jobs: + build-linux64: + name: Build linux64 + runs-on: ubuntu-22.04 + steps: + - name: Install basic build dependencies + run: | + sudo apt-get update + sudo apt-get install ninja-build + - name: Install binary build dependencies + if: inputs.platform-files || inputs.xml-dump-type-sizes + run: | + sudo apt-get install \ + ccache \ + gcc-${{ inputs.gcc-ver }} \ + g++-${{ inputs.gcc-ver }} \ + libxml-libxslt-perl + - name: Install stonesense dependencies + if: inputs.stonesense + run: sudo apt-get install libgl-dev + - name: Install doc dependencies + if: inputs.docs + run: pip install 'sphinx' + - name: Clone DFHack + uses: actions/checkout@v4 + with: + repository: ${{ inputs.dfhack_repo }} + ref: ${{ inputs.dfhack_ref }} + submodules: true + fetch-depth: ${{ !inputs.platform-files && 1 || 0 }} + - name: Clone scripts + if: inputs.scripts_ref + uses: actions/checkout@v4 + with: + repository: ${{ inputs.scripts_repo }} + ref: ${{ inputs.scripts_ref }} + path: scripts + - name: Clone structures + if: inputs.structures_ref + uses: actions/checkout@v4 + with: + repository: ${{ inputs.structures_repo }} + ref: ${{ inputs.structures_ref }} + path: library/xml + - name: Clone stonesense + if: inputs.stonesense_ref + uses: actions/checkout@v4 + with: + repository: ${{ inputs.stonesense_repo }} + ref: ${{ inputs.stonesense_ref }} + path: plugins/stonesense + - name: Get 3rd party SDKs + if: inputs.launchdf + uses: actions/checkout@v4 + with: + repository: DFHack/3rdparty + ref: main + ssh-key: ${{ secrets.DFHACK_3RDPARTY_TOKEN }} + path: depends/steam + - name: Fetch ccache + if: inputs.platform-files + uses: actions/cache/restore@v4 + with: + path: ~/.cache/ccache + key: linux-gcc-${{ inputs.gcc-ver }}-${{ inputs.cache-id }}-${{ github.sha }} + restore-keys: | + linux-gcc-${{ inputs.gcc-ver }}-${{ inputs.cache-id }} + linux-gcc-${{ inputs.gcc-ver }} + - name: Configure DFHack + env: + CC: gcc-${{ inputs.gcc-ver }} + CXX: g++-${{ inputs.gcc-ver }} + run: | + cmake \ + -S . \ + -B build \ + -G Ninja \ + -DCMAKE_INSTALL_PREFIX=build/image \ + -DCMAKE_BUILD_TYPE=Release \ + -DDFHACK_RUN_URL='https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}' \ + ${{ inputs.platform-files && '-DCMAKE_C_COMPILER_LAUNCHER=ccache' || '' }} \ + ${{ inputs.platform-files && '-DCMAKE_CXX_COMPILER_LAUNCHER=ccache' || '' }} \ + -DBUILD_LIBRARY:BOOL=${{ inputs.platform-files }} \ + -DBUILD_PLUGINS:BOOL=${{ inputs.platform-files && inputs.plugins }} \ + -DBUILD_STONESENSE:BOOL=${{ inputs.stonesense }} \ + -DBUILD_DFLAUNCH:BOOL=${{ inputs.launchdf }} \ + -DBUILD_DEV_PLUGINS:BOOL=${{ inputs.extras }} \ + -DBUILD_SIZECHECK:BOOL=${{ inputs.extras }} \ + -DBUILD_SKELETON:BOOL=${{ inputs.extras }} \ + -DBUILD_DOCS:BOOL=${{ inputs.docs }} \ + -DBUILD_DOCS_NO_HTML:BOOL=${{ !inputs.html }} \ + -DBUILD_TESTS:BOOL=${{ inputs.tests }} \ + -DBUILD_XMLDUMP:BOOL=${{ inputs.xml-dump-type-sizes }} \ + ${{ inputs.xml-dump-type-sizes && '-DINSTALL_XMLDUMP:BOOL=1' || ''}} \ + -DINSTALL_DATA_FILES:BOOL=${{ inputs.common-files }} \ + -DINSTALL_SCRIPTS:BOOL=${{ inputs.common-files }} + - name: Build DFHack + run: ninja -C build install + - name: Run cpp tests + if: inputs.platform-files + run: ninja -C build test + - name: Finalize ccache + if: inputs.platform-files + run: | + ccache --show-stats --verbose + ccache --max-size 40M + ccache --cleanup + ccache --max-size 500M + ccache --zero-stats + - name: Save ccache + if: inputs.platform-files && !inputs.cache-readonly + uses: actions/cache/save@v4 + with: + path: ~/.cache/ccache + key: linux-gcc-${{ inputs.gcc-ver }}-${{ inputs.cache-id }}-${{ github.sha }} + - name: Format artifact name + if: inputs.artifact-name + id: artifactname + run: | + if test "false" = "${{ inputs.append-date-and-hash }}"; then + echo name=${{ inputs.artifact-name }} >> $GITHUB_OUTPUT + else + echo name=${{ inputs.artifact-name }}-$(date +%Y%m%d)-$(git rev-parse --short HEAD) >> $GITHUB_OUTPUT + fi + - name: Prep artifact + if: inputs.artifact-name + run: | + cd build/image + tar cjf ../../${{ steps.artifactname.outputs.name }}.tar.bz2 . + - name: Upload artifact + if: inputs.artifact-name + uses: actions/upload-artifact@v4 + with: + name: ${{ steps.artifactname.outputs.name }} + path: ${{ steps.artifactname.outputs.name }}.tar.bz2 diff --git a/.github/workflows/build-windows.yml b/.github/workflows/build-windows.yml new file mode 100644 index 0000000000..1dec211117 --- /dev/null +++ b/.github/workflows/build-windows.yml @@ -0,0 +1,206 @@ +name: Build win64 + +on: + workflow_call: + inputs: + dfhack_repo: + type: string + default: DFHack/dfhack + dfhack_ref: + type: string + scripts_repo: + type: string + default: DFHack/scripts + scripts_ref: + type: string + structures_repo: + type: string + default: DFHack/df-structures + structures_ref: + type: string + stonesense_repo: + type: string + default: DFHack/stonesense + stonesense_ref: + type: string + artifact-name: + type: string + append-date-and-hash: + type: boolean + default: false + cache-id: + type: string + default: '' + cache-readonly: + type: boolean + default: false + platform-files: + type: boolean + default: true + plugins: + type: boolean + default: true + common-files: + type: boolean + default: true + docs: + type: boolean + default: false + html: + type: boolean + default: true + stonesense: + type: boolean + default: false + tests: + type: boolean + default: false + xml-dump-type-sizes: + type: boolean + default: false + launchdf: + type: boolean + default: false + + +jobs: + build-win64: + name: Build win64 + runs-on: windows-2022 + steps: + - name: Set up Python + uses: actions/setup-python@v6 + with: + python-version: '3.x' + - name: Install build dependencies + run: | + choco install sccache + pip install Jinja2 + - name: Install doc dependencies + if: inputs.docs + run: | + pip install sphinx + - name: Clone DFHack + uses: actions/checkout@v4 + with: + repository: ${{ inputs.dfhack_repo }} + ref: ${{ inputs.dfhack_ref }} + submodules: true + fetch-depth: 0 + - name: Clone scripts + if: inputs.scripts_ref + uses: actions/checkout@v4 + with: + repository: ${{ inputs.scripts_repo }} + ref: ${{ inputs.scripts_ref }} + path: scripts + - name: Clone structures + if: inputs.structures_ref + uses: actions/checkout@v4 + with: + repository: ${{ inputs.structures_repo }} + ref: ${{ inputs.structures_ref }} + path: library/xml + - name: Clone stonesense + if: inputs.stonesense_ref + uses: actions/checkout@v4 + with: + repository: ${{ inputs.stonesense_repo }} + ref: ${{ inputs.stonesense_ref }} + path: plugins/stonesense + - name: Get 3rd party SDKs + if: inputs.launchdf + uses: actions/checkout@v4 + with: + repository: DFHack/3rdparty + ref: main + ssh-key: ${{ secrets.DFHACK_3RDPARTY_TOKEN }} + path: depends/steam + - name: Prepare output directories + run: | + mkdir output + mkdir pdb + - name: Get sccache path + run: echo ("SCCACHE_DIR=" + $env:LOCALAPPDATA + "\Mozilla\sccache\cache") >> $env:GITHUB_ENV + - name: Fetch ccache + if: inputs.platform-files + uses: actions/cache/restore@v4 + with: + path: ${{ env.SCCACHE_DIR }} + key: win-msvc-${{ inputs.cache-id }}-${{ github.sha }} + restore-keys: | + win-msvc-${{ inputs.cache-id }} + win-msvc + - uses: ilammy/msvc-dev-cmd@v1 + - name: Configure DFHack + run: | + cmake ` + -S . ` + -B build ` + -GNinja ` + -DDFHACK_BUILD_ARCH=64 ` + -DCMAKE_BUILD_TYPE=Release ` + -DCMAKE_INSTALL_PREFIX=output ` + -DCMAKE_C_COMPILER_LAUNCHER=sccache ` + -DCMAKE_CXX_COMPILER_LAUNCHER=sccache ` + -DBUILD_PDBS:BOOL=${{ inputs.cache-id == 'release' }} ` + -DDFHACK_RUN_URL='https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}' ` + -DBUILD_LIBRARY=${{ inputs.platform-files }} ` + -DBUILD_PLUGINS:BOOL=${{ inputs.platform-files && inputs.plugins }} ` + -DBUILD_STONESENSE:BOOL=${{ inputs.stonesense }} ` + -DBUILD_DOCS:BOOL=${{ inputs.docs }} ` + -DBUILD_DOCS_NO_HTML:BOOL=${{ !inputs.html }} ` + -DINSTALL_DATA_FILES:BOOL=${{ inputs.common-files }} ` + -DBUILD_DFLAUNCH:BOOL=${{ inputs.launchdf }} ` + -DBUILD_TESTS:BOOL=${{ inputs.tests }} ` + -DBUILD_XMLDUMP:BOOL=${{ inputs.xml-dump-type-sizes }} ` + ${{ inputs.xml-dump-type-sizes && '-DINSTALL_XMLDUMP:BOOL=1' || '' }} + - name: Build DFHack + env: + SCCACHE_CACHE_SIZE: 500M + run: | + ninja install -C build + - name: Finalize cache + run: | + cd build + sccache --show-stats + sccache --zero-stats + - name: Save ccache + if: inputs.platform-files && !inputs.cache-readonly + uses: actions/cache/save@v4 + with: + path: ${{ env.SCCACHE_DIR }} + key: win-msvc-${{ inputs.cache-id }}-${{ github.sha }} + - name: Format artifact name + if: inputs.artifact-name + id: artifactname + run: | + if ("${{ inputs.append-date-and-hash }}" -eq "false") { + "name=${{ inputs.artifact-name }}" | Out-File -Append $env:GITHUB_OUTPUT + } else { + $date = Get-Date -Format "yyyMMdd" + $hash = git rev-parse --short HEAD + "name=${{ inputs.artifact-name}}-$date-$hash" | Out-File -Append $env:GITHUB_OUTPUT + } + - name: Prep pdbs + if: inputs.artifact-name && inputs.cache-id == 'release' + run: | + Get-ChildItem -Recurse -File -Path "build" -Filter *.pdb | + Copy-Item -Destination "pdb" + - name: Prep artifact + run: | + cd output + 7z a -ttar -so -an . | + 7z a -si -tbzip2 ../${{ steps.artifactname.outputs.name }}.tar.bz2 + - name: Upload artifact + if: inputs.artifact-name + uses: actions/upload-artifact@v4 + with: + name: ${{ steps.artifactname.outputs.name }} + path: ${{ steps.artifactname.outputs.name }}.tar.bz2 + - name: Upload PDBs + if: inputs.artifact-name && inputs.cache-id == 'release' + uses: actions/upload-artifact@v4 + with: + name: ${{ steps.artifactname.outputs.name }}_pdb + path: pdb diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000000..3767b42ba5 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,46 @@ +name: Build + +on: [push, pull_request] + +jobs: + test: + uses: ./.github/workflows/test.yml + with: + dfhack_repo: ${{ github.repository }} + dfhack_ref: ${{ github.ref }} + secrets: inherit + + package: + uses: ./.github/workflows/package.yml + with: + dfhack_repo: ${{ github.repository }} + dfhack_ref: ${{ github.ref }} + secrets: inherit + + docs: + uses: ./.github/workflows/build-linux.yml + with: + dfhack_repo: ${{ github.repository }} + dfhack_ref: ${{ github.ref }} + platform-files: false + common-files: false + docs: true + secrets: inherit + + lint: + uses: ./.github/workflows/lint.yml + with: + dfhack_repo: ${{ github.repository }} + dfhack_ref: ${{ github.ref }} + secrets: inherit + + check-pr: + runs-on: ubuntu-latest + if: github.event_name == 'pull_request' + steps: + - name: Check that PR is based on develop branch + env: + BASE_BRANCH: ${{ github.base_ref }} + run: | + echo "PR base branch: $BASE_BRANCH" + test "$BASE_BRANCH" = develop diff --git a/.github/workflows/clean-cache.yml b/.github/workflows/clean-cache.yml new file mode 100644 index 0000000000..91d5675ad8 --- /dev/null +++ b/.github/workflows/clean-cache.yml @@ -0,0 +1,32 @@ +name: Clean up PR caches + +on: + workflow_call: + pull_request_target: + types: + - closed + +jobs: + cleanup: + runs-on: ubuntu-latest + steps: + - name: Check out code + uses: actions/checkout@v4 + - name: Cleanup + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + gh extension install actions/gh-actions-cache + + REPO=${{ github.repository }} + BRANCH="refs/pull/${{ github.event.pull_request.number }}/merge" + + echo "Fetching list of cache keys" + cacheKeysForPR=$(gh actions-cache list -R $REPO -B $BRANCH -L 100 | cut -f 1) + + set +e + echo "Deleting caches..." + for cacheKey in $cacheKeysForPR; do + gh actions-cache delete $cacheKey -R $REPO -B $BRANCH --confirm + done + echo "Done" diff --git a/.github/workflows/generate-symbols.yml b/.github/workflows/generate-symbols.yml new file mode 100644 index 0000000000..f78da19e74 --- /dev/null +++ b/.github/workflows/generate-symbols.yml @@ -0,0 +1,421 @@ +name: Generate symbols + +on: + workflow_dispatch: + inputs: + structures_ref: + description: Structures branch to build from and update + required: true + default: master + version: + description: DF version (can be "auto" if channel is steam) + required: true + platform: + description: Target OS platform + type: choice + required: true + default: all + options: + - all + - windows + - linux + channel: + description: DF distribution channel + type: choice + required: true + default: all + options: + - all + - steam + - itch + - classic + df_steam_branch: + description: DF Steam branch to read from (if processing Steam distribution channel) + required: true + type: choice + default: default + options: + - default + - experimental + - testing + - adventure_test + - beta + steam_branch: + description: DFHack Steam branch to deploy to (leave blank to skip deploy) + type: string + +jobs: + package-linux: + uses: ./.github/workflows/build-linux.yml + if: inputs.platform == 'all' || inputs.platform == 'linux' + with: + dfhack_ref: ${{ github.ref }} + structures_ref: ${{ inputs.structures_ref }} + artifact-name: dfhack-symbols-linux64-build + append-date-and-hash: false + cache-id: test + cache-readonly: true + plugins: false + secrets: inherit + + package-win64: + uses: ./.github/workflows/build-windows.yml + if: (inputs.platform == 'all' || inputs.platform == 'windows') && inputs.version == 'auto' + with: + dfhack_ref: ${{ github.ref }} + structures_ref: ${{ inputs.structures_ref }} + artifact-name: dfhack-symbols-windows64-build + append-date-and-hash: false + cache-id: test + cache-readonly: true + plugins: false + secrets: inherit + + generate-linux: + name: Generate linux64 symbols + runs-on: ubuntu-latest + if: inputs.platform == 'all' || inputs.platform == 'linux' + needs: + - package-linux + steps: + - name: Install dependencies + run: | + sudo apt-get update + sudo apt-get install \ + ansifilter \ + libsdl2-2.0-0 \ + libsdl2-image-2.0-0 + - name: Clone structures + uses: actions/checkout@v4 + with: + repository: DFHack/df-structures + ref: ${{ inputs.structures_ref }} + token: ${{ secrets.DFHACK_GITHUB_TOKEN }} + path: xml + - name: Download DFHack + uses: actions/download-artifact@v4 + with: + name: dfhack-symbols-linux64-build + - name: Start X server + run: Xvfb :0 -screen 0 1600x1200x24 & + + # Steam + - name: Setup steamcmd + if: inputs.channel == 'all' || inputs.channel == 'steam' + id: steamcmd + uses: CyberAndrii/setup-steamcmd@v1 + - name: Generate Steam symbols + if: inputs.channel == 'all' || inputs.channel == 'steam' + env: + DISPLAY: :0 + STEAM_USERNAME: ${{ secrets.STEAM_USERNAME }} + STEAM_CONFIG_VDF: ${{ secrets.STEAM_CONFIG_VDF }} + STEAM_DF_TESTING: ${{ secrets.STEAM_DF_TESTING }} + STEAM_DF_ADVENTURE_TEST: ${{ secrets.STEAM_DF_ADVENTURE_TEST }} + run: | + mkdir DF_steam + mkdir -p $HOME/Steam/config + echo "$STEAM_CONFIG_VDF" | base64 -d >$HOME/Steam/config/config.vdf + echo "DF steam branch: ${{ inputs.df_steam_branch }}" + if [ "${{ inputs.df_steam_branch }}" = "default" ]; then + BETA_PARAMS="" + elif [ "${{ inputs.df_steam_branch }}" = "testing" ]; then + BETA_PARAMS="-beta testing -betapassword $STEAM_DF_TESTING" + elif [ "${{ inputs.df_steam_branch }}" = "adventure_test" ]; then + BETA_PARAMS="-beta adventure_test -betapassword $STEAM_DF_ADVENTURE_TEST" + else + BETA_PARAMS="-beta ${{ inputs.df_steam_branch }}" + fi + ${{ steps.steamcmd.outputs.executable }} \ + +@ShutdownOnFailedCommand 1 \ + +force_install_dir $PWD/DF_steam \ + +login $STEAM_USERNAME \ + "+app_update 975370 $BETA_PARAMS validate" \ + +quit + tar xjf dfhack-symbols-linux64-build.tar.bz2 -C DF_steam + xml/symbols_gen_linux.sh ${{ inputs.version == 'auto' && '50.0' || inputs.version }} STEAM DF_steam + if [ "${{ inputs.version }}" == "auto" ]; then + while pgrep dwarfort; do + echo "waiting for DF to exit" + sleep 0.5 + done + cp xml/symbols.xml DF_steam/hack + cd DF_steam + DFHACK_DISABLE_CONSOLE=1 ./dfhack & + while ! ./dfhack-run lua 'print(scr)' | fgrep 'viewscreen_titlest' 2>/dev/null; do + echo "waiting for DF to start" + sleep 0.5 + done + df_ver=`./dfhack-run lua 'print(dfhack.gui.getDFViewscreen(true).str_version)' | ansifilter` + echo "Found version string: '$df_ver'" + echo "DETECTED_DF_VER=$df_ver" >>$GITHUB_ENV + sed -i "s/v0.50.0 linux64 STEAM/v0.$df_ver linux64 STEAM/" ../xml/symbols.xml + ./dfhack-run die || true + fi + + # Itch + - name: Generate Itch symbols + if: (inputs.channel == 'all' || inputs.channel == 'itch') && inputs.version != 'auto' + env: + DISPLAY: :0 + ITCH_API_KEY: ${{ secrets.ITCH_API_KEY }} + run: | + mkdir DF_itch + pip install itch-dl + minor=$(echo "${{ inputs.version }}" | cut -d. -f1) + patch=$(echo "${{ inputs.version }}" | cut -d. -f2) + fname="dwarf_fortress_${minor}_${patch}_linux.tar.bz2" + itch-dl https://kitfoxgames.itch.io/dwarf-fortress --download-to . --api-key $ITCH_API_KEY --filter-files-glob "${fname}" + tar xjf "kitfoxgames/dwarf-fortress/files/${fname}" -C DF_itch + tar xjf dfhack-symbols-linux64-build.tar.bz2 -C DF_itch + xml/symbols_gen_linux.sh ${{ inputs.version }} ITCH DF_itch + + # Classic + - name: Generate Classic symbols + if: (inputs.channel == 'all' || inputs.channel == 'classic') && inputs.version != 'auto' + env: + DISPLAY: :0 + run: | + mkdir DF_classic + minor=$(echo "${{ inputs.version }}" | cut -d. -f1) + patch=$(echo "${{ inputs.version }}" | cut -d. -f2) + fname="df_${minor}_${patch}_linux.tar.bz2" + wget "https://www.bay12games.com/dwarves/${fname}" + tar xjf "${fname}" -C DF_classic + tar xjf dfhack-symbols-linux64-build.tar.bz2 -C DF_classic + xml/symbols_gen_linux.sh ${{ inputs.version }} CLASSIC DF_classic + + # Finalize + - name: Merge updates + run: | + cd xml + if ! git diff --exit-code; then + git stash + git pull + git stash pop + fi + - name: Commit symbol updates + uses: stefanzweifel/git-auto-commit-action@v5 + with: + commit_message: Auto-update symbols for Linux DF version ${{ env.DETECTED_DF_VER || inputs.version }} + repository: xml + commit_user_name: DFHack-Urist via GitHub Actions + commit_user_email: 63161697+DFHack-Urist@users.noreply.github.com + + generate-windows: + name: Generate win64 symbols + runs-on: ubuntu-latest + if: inputs.platform == 'all' || inputs.platform == 'windows' + steps: + - name: Install dependencies + run: pip install pefile + - name: Clone structures + uses: actions/checkout@v4 + with: + repository: DFHack/df-structures + ref: ${{ inputs.structures_ref }} + token: ${{ secrets.DFHACK_GITHUB_TOKEN }} + path: xml + - name: Clone df_misc + uses: actions/checkout@v4 + with: + repository: DFHack/df_misc + path: df_misc + - name: Clone metasm + uses: actions/checkout@v4 + with: + repository: jjyg/metasm + path: metasm + + # Steam + - name: Setup steamcmd + if: inputs.channel == 'all' || inputs.channel == 'steam' + id: steamcmd + uses: CyberAndrii/setup-steamcmd@v1 + - name: Generate Steam symbols + if: inputs.channel == 'all' || inputs.channel == 'steam' + env: + STEAM_USERNAME: ${{ secrets.STEAM_USERNAME }} + STEAM_CONFIG_VDF: ${{ secrets.STEAM_CONFIG_VDF }} + STEAM_DF_TESTING: ${{ secrets.STEAM_DF_TESTING }} + STEAM_DF_ADVENTURE_TEST: ${{ secrets.STEAM_DF_ADVENTURE_TEST }} + run: | + mkdir DF_steam + mkdir -p $HOME/Steam/config + echo "$STEAM_CONFIG_VDF" | base64 -d >$HOME/Steam/config/config.vdf + echo "DF steam branch: ${{ inputs.df_steam_branch }}" + if [ "${{ inputs.df_steam_branch }}" = "default" ]; then + BETA_PARAMS="" + elif [ "${{ inputs.df_steam_branch }}" = "testing" ]; then + BETA_PARAMS="-beta testing -betapassword $STEAM_DF_TESTING" + elif [ "${{ inputs.df_steam_branch }}" = "adventure_test" ]; then + BETA_PARAMS="-beta adventure_test -betapassword $STEAM_DF_ADVENTURE_TEST" + else + BETA_PARAMS="-beta ${{ inputs.df_steam_branch }}" + fi + ${{ steps.steamcmd.outputs.executable }} \ + +@ShutdownOnFailedCommand 1 \ + +@sSteamCmdForcePlatformType windows \ + +force_install_dir $PWD/DF_steam \ + +login $STEAM_USERNAME \ + "+app_update 975370 $BETA_PARAMS validate" \ + +quit + xml/symbols_gen_windows.sh ${{ inputs.version == 'auto' && '50.0' || inputs.version }} STEAM DF_steam + + # Itch + - name: Generate Itch symbols + if: (inputs.channel == 'all' || inputs.channel == 'itch') && inputs.version != 'auto' + env: + ITCH_API_KEY: ${{ secrets.ITCH_API_KEY }} + run: | + mkdir DF_itch + pip install itch-dl + minor=$(echo "${{ inputs.version }}" | cut -d. -f1) + patch=$(echo "${{ inputs.version }}" | cut -d. -f2) + fname="dwarf_fortress_${minor}_${patch}_windows.zip" + itch-dl https://kitfoxgames.itch.io/dwarf-fortress --download-to . --api-key $ITCH_API_KEY --filter-files-glob "${fname}" + unzip -d DF_itch "kitfoxgames/dwarf-fortress/files/${fname}" + xml/symbols_gen_windows.sh ${{ inputs.version }} ITCH DF_itch + + # Classic + - name: Generate Classic symbols + if: (inputs.channel == 'all' || inputs.channel == 'classic') && inputs.version != 'auto' + run: | + mkdir DF_classic + minor=$(echo "${{ inputs.version }}" | cut -d. -f1) + patch=$(echo "${{ inputs.version }}" | cut -d. -f2) + fname="df_${minor}_${patch}_win.zip" + wget "https://www.bay12games.com/dwarves/${fname}" + unzip -d DF_classic "${fname}" + xml/symbols_gen_windows.sh ${{ inputs.version }} CLASSIC DF_classic + + # Finalize + - name: Merge updates + run: | + cd xml + if ! git diff --exit-code; then + git stash + git pull + git stash pop + fi + - name: Commit symbol updates + uses: stefanzweifel/git-auto-commit-action@v5 + with: + commit_message: Auto-update symbols for Windows DF version ${{ inputs.version }} + repository: xml + commit_user_name: DFHack-Urist via GitHub Actions + commit_user_email: 63161697+DFHack-Urist@users.noreply.github.com + + auto-ver-windows: + name: Autodetect DF version string (Windows) + if: (inputs.platform == 'all' || inputs.platform == 'windows') && (inputs.channel == 'all' || inputs.channel == 'steam') && inputs.version == 'auto' + needs: + - package-win64 + - generate-windows + runs-on: windows-latest + steps: + - name: Clone structures + uses: actions/checkout@v4 + with: + repository: DFHack/df-structures + ref: ${{ inputs.structures_ref }} + token: ${{ secrets.DFHACK_GITHUB_TOKEN }} + path: xml + - name: Download DFHack + uses: actions/download-artifact@v4 + with: + name: dfhack-symbols-windows64-build + - name: Setup steamcmd + id: steamcmd + uses: CyberAndrii/setup-steamcmd@v1 + - name: Update DF version string + env: + STEAM_USERNAME: ${{ secrets.STEAM_USERNAME }} + STEAM_CONFIG_VDF: ${{ secrets.STEAM_CONFIG_VDF }} + STEAM_DF_TESTING: ${{ secrets.STEAM_DF_TESTING }} + STEAM_DF_ADVENTURE_TEST: ${{ secrets.STEAM_DF_ADVENTURE_TEST }} + shell: bash + run: | + mkdir DF_steam + echo "$STEAM_CONFIG_VDF" | base64 -d >${{ steps.steamcmd.outputs.directory }}/config/config.vdf + echo "DF steam branch: ${{ inputs.df_steam_branch }}" + if [ "${{ inputs.df_steam_branch }}" = "default" ]; then + BETA_PARAMS="" + elif [ "${{ inputs.df_steam_branch }}" = "testing" ]; then + BETA_PARAMS="-beta testing -betapassword $STEAM_DF_TESTING" + elif [ "${{ inputs.df_steam_branch }}" = "adventure_test" ]; then + BETA_PARAMS="-beta adventure_test -betapassword $STEAM_DF_ADVENTURE_TEST" + else + BETA_PARAMS="-beta ${{ inputs.df_steam_branch }}" + fi + ${{ steps.steamcmd.outputs.executable }} \ + +@ShutdownOnFailedCommand 1 \ + +@sSteamCmdForcePlatformType windows \ + +force_install_dir $PWD/DF_steam \ + +login $STEAM_USERNAME \ + "+app_update 975370 $BETA_PARAMS validate" \ + +quit + tar xjf dfhack-symbols-windows64-build.tar.bz2 -C DF_steam + cp xml/symbols.xml DF_steam/hack + cd DF_steam + "./Dwarf Fortress.exe" & + while ! ./dfhack-run.exe lua 'print(scr)' | fgrep 'viewscreen_titlest' 2>/dev/null; do + echo "waiting for DF to start" + sleep 0.5 + done + df_ver=`./dfhack-run.exe lua 'print(dfhack.gui.getDFViewscreen(true).str_version)'` + echo "Found version string: '$df_ver'" + echo "DETECTED_DF_VER=$df_ver" >>$GITHUB_ENV + sed -i "s/v0.50.0 win64 STEAM/v0.$df_ver win64 STEAM/" ../xml/symbols.xml + ./dfhack-run.exe die || true + - name: Merge updates + shell: bash + run: | + cd xml + if ! git diff --exit-code; then + git stash + git pull + git stash pop + fi + - name: Commit symbol updates + uses: stefanzweifel/git-auto-commit-action@v5 + with: + commit_message: Auto-update Windows DF version to ${{ env.DETECTED_DF_VER }} in symbols + repository: xml + commit_user_name: DFHack-Urist via GitHub Actions + commit_user_email: 63161697+DFHack-Urist@users.noreply.github.com + + update-ref: + name: Update structures ref + runs-on: ubuntu-latest + needs: + - generate-linux + - auto-ver-windows + if: ${{ ! failure() }} + steps: + - name: Clone DFHack + uses: actions/checkout@v4 + with: + token: ${{ secrets.DFHACK_GITHUB_TOKEN }} + - name: Update ref + shell: bash + run: | + git submodule update --init --no-single-branch library/xml + cd library/xml + git checkout ${{ inputs.structures_ref }} + git pull + df_ver=`grep -E 'symbol-table.*STEAM' symbols.xml | head -n1 | sed -r "s/.*name='v0.([^ ]+) .*/\1/"` + echo "using DF version: $df_ver" + echo "DETECTED_DF_VER=$df_ver" >>$GITHUB_ENV + - name: Commit ref update + uses: stefanzweifel/git-auto-commit-action@v5 + with: + commit_message: Auto-update structures ref for ${{ env.DETECTED_DF_VER }} + commit_user_name: DFHack-Urist via GitHub Actions + commit_user_email: 63161697+DFHack-Urist@users.noreply.github.com + - name: Launch steam-deploy + if: inputs.steam_branch + shell: bash + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: gh workflow run steam-deploy.yml -R DFHack/dfhack -r ${{ github.ref }} -f version=${{ env.DETECTED_DF_VER }} -f steam_branch=${{ inputs.steam_branch }} diff --git a/.github/workflows/github-release.yml b/.github/workflows/github-release.yml new file mode 100644 index 0000000000..16a4602141 --- /dev/null +++ b/.github/workflows/github-release.yml @@ -0,0 +1,81 @@ +name: Deploy to GitHub + +on: + push: + tags: + - '*-r*' + + workflow_dispatch: + inputs: + ref: + description: Tag + required: true + +jobs: + package: + uses: ./.github/workflows/package.yml + with: + dfhack_ref: ${{ github.event.inputs && github.event.inputs.ref || github.event.ref }} + append-date-and-hash: false + cache-readonly: true + launchdf: true + secrets: inherit + + create-update-release: + name: Draft GitHub release + needs: package + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - name: Install doc dependencies + run: pip install 'sphinx' + - name: Clone DFHack + uses: actions/checkout@v4 + with: + ref: ${{ github.event.inputs && github.event.inputs.ref || github.event.ref }} + submodules: true + - name: Get tag + id: gettag + run: | + TAG=$(git describe --tags --abbrev=0 --exact-match) + echo name="$TAG" >> $GITHUB_OUTPUT + echo type=$(echo "$TAG" | egrep 'r[0-9]+$' && echo "release" || echo "prerelease") >> $GITHUB_OUTPUT + - name: Generate release text + run: | + python docs/gen_changelog.py -a + CHANGELOG_FILE=docs/changelogs/${{ steps.gettag.outputs.name }}-github.txt + if ! test -f $CHANGELOG_FILE; then CHANGELOG_FILE=docs/changelogs/future-github.txt; fi + TOKEN_LINE=$(grep -Fhne '%RELEASE_NOTES%' .github/release_template.md | sed 's/:.*//') + head -n $((TOKEN_LINE - 1)) .github/release_template.md > release_body.md + CHANGELOG_LINES=$(wc -l <$CHANGELOG_FILE) + tail -n $((CHANGELOG_LINES - 3)) $CHANGELOG_FILE >> release_body.md + tail -n 1 .github/release_template.md >> release_body.md + cat release_body.md + - name: Stage release + uses: actions/download-artifact@v4 + - name: Prep artifacts + run: | + mkdir artifacts + cd dfhack-windows64-build + tar xjf dfhack-windows64-build.tar.bz2 + rm dfhack-windows64-build.tar.bz2 + zip -qr ../artifacts/dfhack-${{ steps.gettag.outputs.name }}-Windows-64bit.zip . + cd ../dfhack-linux64-build + mv dfhack-linux64-build.tar.bz2 ../artifacts/dfhack-${{ steps.gettag.outputs.name }}-Linux-64bit.tar.bz2 + - name: Create or update GitHub release + uses: ncipollo/release-action@v1 + with: + artifacts: "artifacts/dfhack-*" + bodyFile: "release_body.md" + allowUpdates: true + artifactErrorsFailBuild: true + draft: true + name: "DFHack ${{ steps.gettag.outputs.name }}" + omitBodyDuringUpdate: true + omitDraftDuringUpdate: true + omitNameDuringUpdate: true + omitPrereleaseDuringUpdate: true + prerelease: ${{ steps.gettag.outputs.type == 'prerelease' }} + replacesArtifacts: true + tag: ${{ steps.gettag.outputs.name }} diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000000..0b44747c01 --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,50 @@ +name: Lint + +on: + workflow_call: + inputs: + dfhack_repo: + type: string + default: DFHack/dfhack + dfhack_ref: + type: string + scripts_repo: + type: string + default: DFHack/scripts + scripts_ref: + type: string + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - name: Install Lua + run: | + sudo apt-get update + sudo apt-get install lua5.3 + - name: Clone DFHack + uses: actions/checkout@v4 + with: + repository: ${{ inputs.dfhack_repo }} + ref: ${{ inputs.dfhack_ref }} + - name: Get scripts submodule ref + if: '!inputs.scripts_ref' + id: scriptssubmoduleref + run: echo ref=$(git submodule | fgrep scripts | cut -c2-41) >> $GITHUB_OUTPUT + - name: Clone scripts + uses: actions/checkout@v4 + with: + repository: ${{ inputs.scripts_repo }} + ref: ${{ inputs.scripts_ref || steps.scriptssubmoduleref.outputs.ref }} + path: scripts + - name: Check whitespace + run: python ci/lint.py --git-only --github-actions + - name: Check Authors.rst + if: always() + run: python ci/authors-rst.py + - name: Check for missing documentation + if: always() + run: python ci/script-docs.py + - name: Check Lua syntax + if: always() + run: python ci/script-syntax.py --ext=lua --cmd="luac5.3 -p" --github-actions diff --git a/.github/workflows/package.yml b/.github/workflows/package.yml new file mode 100644 index 0000000000..41e72ea636 --- /dev/null +++ b/.github/workflows/package.yml @@ -0,0 +1,76 @@ +name: Package + +on: + workflow_call: + inputs: + dfhack_repo: + type: string + dfhack_ref: + type: string + scripts_repo: + type: string + scripts_ref: + type: string + structures_repo: + type: string + structures_ref: + type: string + append-date-and-hash: + type: boolean + default: true + cache-readonly: + type: boolean + default: false + launchdf: + type: boolean + default: false + include_windows: + type: boolean + default: true + include_linux: + type: boolean + default: true + + +jobs: + package-win64: + name: Windows + uses: ./.github/workflows/build-windows.yml + if: inputs.include_windows + with: + dfhack_repo: ${{ inputs.dfhack_repo }} + dfhack_ref: ${{ inputs.dfhack_ref }} + scripts_repo: ${{ inputs.scripts_repo }} + scripts_ref: ${{ inputs.scripts_ref }} + structures_repo: ${{ inputs.structures_repo }} + structures_ref: ${{ inputs.structures_ref }} + artifact-name: dfhack-windows64-build + append-date-and-hash: ${{ inputs.append-date-and-hash }} + cache-id: release + cache-readonly: ${{ inputs.cache-readonly }} + stonesense: true + docs: true + html: false + launchdf: ${{ inputs.launchdf }} + secrets: inherit + + package-linux: + name: Linux + uses: ./.github/workflows/build-linux.yml + if: inputs.include_linux + with: + dfhack_repo: ${{ inputs.dfhack_repo }} + dfhack_ref: ${{ inputs.dfhack_ref }} + scripts_repo: ${{ inputs.scripts_repo }} + scripts_ref: ${{ inputs.scripts_ref }} + structures_repo: ${{ inputs.structures_repo }} + structures_ref: ${{ inputs.structures_ref }} + artifact-name: dfhack-linux64-build + append-date-and-hash: ${{ inputs.append-date-and-hash }} + cache-id: release + cache-readonly: ${{ inputs.cache-readonly }} + stonesense: true + docs: true + html: false + launchdf: ${{ inputs.launchdf }} + secrets: inherit diff --git a/.github/workflows/steam-deploy.yml b/.github/workflows/steam-deploy.yml new file mode 100644 index 0000000000..2fbe6849e1 --- /dev/null +++ b/.github/workflows/steam-deploy.yml @@ -0,0 +1,96 @@ +name: Deploy to Steam + +on: + push: + tags: + - '*-r*' + workflow_dispatch: + inputs: + version: + description: Version or build description + type: string + required: true + steam_branch: + description: Steam release branch + type: string + required: true + default: staging + +jobs: + depot-common: + name: Common depot files + uses: ./.github/workflows/build-linux.yml + with: + artifact-name: common-depot + dfhack_ref: ${{ github.ref }} + platform-files: false + docs: true + html: false + stonesense: true + secrets: inherit + + depot-win64: + name: Windows depot files + uses: ./.github/workflows/build-windows.yml + with: + artifact-name: win64-depot + dfhack_ref: ${{ github.ref }} + cache-id: release + cache-readonly: true + common-files: false + stonesense: true + launchdf: true + secrets: inherit + + depot-linux64: + name: Linux depot files + uses: ./.github/workflows/build-linux.yml + with: + artifact-name: linux64-depot + dfhack_ref: ${{ github.ref }} + cache-id: release + cache-readonly: true + common-files: false + stonesense: true + launchdf: true + secrets: inherit + + deploy-to-steam: + name: Deploy to Steam + needs: + - depot-common + - depot-win64 + - depot-linux64 + runs-on: ubuntu-latest + concurrency: steamdeploy + steps: + - name: Download depot files + uses: actions/download-artifact@v4 + - name: Stage depot files + run: | + for name in common win64 linux64; do + cd ${name}-depot + tar xjf ${name}-depot.tar.bz2 + rm ${name}-depot.tar.bz2 + cd .. + done + - name: Get short SHA of commit + run: echo "SHORT_SHA=`echo ${{ github.sha }} | cut -c1-8`" >>$GITHUB_ENV + - name: steamcmd cache + uses: actions/cache@v4 + with: + path: /home/runner/work/_temp/_github_home + key: steamcmd-${{ github.sha }} + restore-keys: steamcmd + - name: Steam deploy + uses: game-ci/steam-deploy@v3 + with: + username: ${{ secrets.STEAM_USERNAME }} + configVdf: ${{ secrets.STEAM_CONFIG_VDF}} + appId: 2346660 + buildDescription: ${{ github.event.inputs && github.event.inputs.version || github.ref_name }} (${{ env.SHORT_SHA }}) + rootPath: . + depot1Path: common-depot + depot2Path: win64-depot + depot3Path: linux64-depot + releaseBranch: ${{ github.event.inputs && github.event.inputs.steam_branch || 'staging' }} diff --git a/.github/workflows/test-suite.yml b/.github/workflows/test-suite.yml new file mode 100644 index 0000000000..3fbf683b63 --- /dev/null +++ b/.github/workflows/test-suite.yml @@ -0,0 +1,93 @@ +name: Test suite + +on: + workflow_call: + inputs: + dfhack_repo: + type: string + dfhack_ref: + type: string + os: + type: string + compiler: + type: string + plugins: + type: string + config: + type: string + +jobs: + run-tests: + name: Test (${{ inputs.os }}, ${{ inputs.compiler }}, ${{ inputs.plugins }} plugins, ${{ inputs.config }} config) + runs-on: ${{ inputs.os }}-latest + steps: + - name: Set env + shell: bash + run: echo "DF_FOLDER=DF" >>$GITHUB_ENV + - name: Install dependencies + if: inputs.os == 'ubuntu' + run: | + sudo apt-get update + sudo apt-get install \ + libsdl2-2.0-0 \ + libsdl2-image-2.0-0 + - name: Clone DFHack + uses: actions/checkout@v4 + with: + repository: ${{ inputs.dfhack_repo }} + ref: ${{ inputs.dfhack_ref }} + - name: Detect DF version + shell: bash + run: echo DF_VERSION="$(sh ci/get-df-version.sh)" >>$GITHUB_ENV + - name: Fetch DF cache + id: restore-df + uses: actions/cache/restore@v4 + with: + path: ${{ env.DF_FOLDER }} + key: df-${{ inputs.os }}-${{ env.DF_VERSION }}-${{ hashFiles('ci/download-df.sh') }} + - name: Download DF + if: steps.restore-df.outputs.cache-hit != 'true' + run: sh ci/download-df.sh ${{ env.DF_FOLDER }} ${{ inputs.os }} ${{ env.DF_VERSION }} + - name: Save DF cache + if: steps.restore-df.outputs.cache-hit != 'true' + uses: actions/cache/save@v4 + with: + path: ${{ env.DF_FOLDER }} + key: df-${{ inputs.os }}-${{ env.DF_VERSION }}-${{ hashFiles('ci/download-df.sh') }} + - name: Install blank DFHack init scripts + if: inputs.config == 'empty' + shell: bash + run: | + mkdir -p ${{ env.DF_FOLDER }}/dfhack-config/init + cd data/dfhack-config/init + for fname in *.init; do touch ../../../${{ env.DF_FOLDER }}/dfhack-config/init/$fname; done + - name: Download DFHack + uses: actions/download-artifact@v4 + with: + name: test-${{ inputs.compiler }} + - name: Install DFHack + shell: bash + run: tar xjf test-${{ inputs.compiler }}.tar.bz2 -C ${{ env.DF_FOLDER }} + - name: Start X server + if: inputs.os == 'ubuntu' + run: Xvfb :0 -screen 0 1600x1200x24 & + - name: Run lua tests + uses: nick-fields/retry@v3 + env: + DISPLAY: :0 + TERM: xterm-256color + with: + timeout_minutes: 1 + command: python ci/run-tests.py --keep-status "${{ env.DF_FOLDER }}" + - name: Check RPC interface + run: python ci/check-rpc.py "${{ env.DF_FOLDER }}/dfhack-rpc.txt" + - name: Upload test artifacts + uses: actions/upload-artifact@v4 + if: always() + continue-on-error: true + with: + name: test-output-${{ inputs.compiler }}-${{ inputs.plugins }}_plugins-${{ inputs.config }}_config + path: | + ${{ env.DF_FOLDER }}/dfhack-rpc.txt + ${{ env.DF_FOLDER }}/test*.json + ${{ env.DF_FOLDER }}/*.log diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000000..175a1adf48 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,113 @@ +name: Test + +on: + workflow_call: + inputs: + dfhack_repo: + type: string + default: DFHack/dfhack + dfhack_ref: + type: string + scripts_repo: + type: string + default: DFHack/scripts + scripts_ref: + type: string + structures_repo: + type: string + default: DFHack/df-structures + structures_ref: + type: string + +jobs: + build-windows: + name: Windows MSVC + uses: ./.github/workflows/build-windows.yml + with: + dfhack_repo: ${{ inputs.dfhack_repo }} + dfhack_ref: ${{ inputs.dfhack_ref }} + scripts_repo: ${{ inputs.scripts_repo }} + scripts_ref: ${{ inputs.scripts_ref }} + structures_repo: ${{ inputs.structures_repo }} + structures_ref: ${{ inputs.structures_ref }} + artifact-name: test-msvc + cache-id: test + docs: true + html: false + tests: true + + build-linux: + name: Linux gcc-${{ matrix.gcc }} + uses: ./.github/workflows/build-linux.yml + with: + dfhack_repo: ${{ inputs.dfhack_repo }} + dfhack_ref: ${{ inputs.dfhack_ref }} + scripts_repo: ${{ inputs.scripts_repo }} + scripts_ref: ${{ inputs.scripts_ref }} + structures_repo: ${{ inputs.structures_repo }} + structures_ref: ${{ inputs.structures_ref }} + artifact-name: test-gcc-${{ matrix.gcc }} + cache-id: test + stonesense: ${{ matrix.plugins == 'all' }} + extras: ${{ matrix.plugins == 'all' }} + docs: true + html: false + tests: true + gcc-ver: ${{ matrix.gcc }} + secrets: inherit + strategy: + fail-fast: false + matrix: + include: + - gcc: 11 # baseline compatibility with ubuntu LTS 22.04 + plugins: "default" + - gcc: 12 # highest available in ubuntu 22.04 + plugins: "all" + + test-windows: + name: Run Windows test suite + needs: build-windows + uses: ./.github/workflows/test-suite.yml + with: + dfhack_repo: ${{ inputs.dfhack_repo }} + dfhack_ref: ${{ inputs.dfhack_ref }} + os: windows + compiler: msvc + plugins: default + config: default + + test-windows-empty: + name: Run Windows test suite (empty config) + needs: build-windows + uses: ./.github/workflows/test-suite.yml + with: + dfhack_repo: ${{ inputs.dfhack_repo }} + dfhack_ref: ${{ inputs.dfhack_ref }} + os: windows + compiler: msvc + plugins: default + config: empty + + test-linux: + name: Run Linux test suite + needs: build-linux + uses: ./.github/workflows/test-suite.yml + with: + dfhack_repo: ${{ inputs.dfhack_repo }} + dfhack_ref: ${{ inputs.dfhack_ref }} + os: ubuntu + compiler: gcc-11 + plugins: default + config: default + + test-linux-gcc-12-all-plugins: + name: Run Linux test suite (gcc-12, all plugins) + needs: build-linux + uses: ./.github/workflows/test-suite.yml + with: + dfhack_repo: ${{ inputs.dfhack_repo }} + dfhack_ref: ${{ inputs.dfhack_ref }} + os: ubuntu + compiler: gcc-12 + plugins: all + config: default diff --git a/.github/workflows/update-submodules.yml b/.github/workflows/update-submodules.yml new file mode 100644 index 0000000000..c634e94d0a --- /dev/null +++ b/.github/workflows/update-submodules.yml @@ -0,0 +1,29 @@ +name: Update submodules + +on: + schedule: + - cron: '0 7 * * *' + workflow_dispatch: + +jobs: + run: + if: ${{ github.event_name == 'workflow_dispatch' || github.repository_owner == 'DFHack' }} + runs-on: ubuntu-latest + steps: + - name: Clone DFHack + uses: actions/checkout@v4 + with: + fetch-depth: 0 + ref: ${{ github.ref }} + submodules: true + token: ${{ secrets.DFHACK_GITHUB_TOKEN }} + - name: Update submodules + run: | + git config user.name "DFHack-Urist via GitHub Actions" + git config user.email "63161697+DFHack-Urist@users.noreply.github.com" + if bash -x ci/update-submodules.bash; then + git push --recurse-submodules=check + elif ! git diff --exit-code HEAD; then + echo "update-submodules.bash failed to commit changes" + exit 1 + fi diff --git a/.github/workflows/watch-df-release.yml b/.github/workflows/watch-df-release.yml new file mode 100644 index 0000000000..50950140d1 --- /dev/null +++ b/.github/workflows/watch-df-release.yml @@ -0,0 +1,159 @@ +name: Watch DF Releases + +on: + schedule: + - cron: '8/10 * * * *' + workflow_dispatch: + +jobs: + check-steam: + if: github.repository == 'DFHack/dfhack' + name: Check Steam (${{ matrix.df_steam_branch }}) for new DF releases + runs-on: ubuntu-latest + concurrency: watch-release-steam-${{ matrix.df_steam_branch }} + strategy: + fail-fast: false + matrix: + # df_steam_branch: which DF Steam branch to watch + # platform: for symbols generation; leave blank to default to all + # structures_ref: leave blank to default to master + # dfhack_ref: leave blank if no structures update is desired + # steam_branch: leave blank if no DFHack steam push is desired + include: + - df_steam_branch: public +# - df_steam_branch: beta +# - df_steam_branch: experimental +# structures_ref: experimental +# dfhack_ref: experimental +# steam_branch: experimental + steps: + - name: Fetch state + uses: actions/cache/restore@v4 + with: + path: state + key: watch-release-steam-${{ matrix.df_steam_branch }} + - name: Compare branch metadata + uses: nick-fields/retry@v3 + with: + timeout_minutes: 5 + retry_wait_seconds: 60 + command: | + blob=$(wget 'https://api.steamcmd.net/v1/info/975370?pretty=1' -O- | \ + awk '/^ *"branches"/,0' | \ + awk '/^ *"${{ matrix.df_steam_branch }}"/,0') + buildid=$(echo "$blob" | \ + fgrep buildid | \ + head -n1 | \ + cut -d'"' -f4) + timestamp=$(echo "$blob" | \ + fgrep timeupdated | \ + head -n1 | \ + cut -d'"' -f4) + test -z "$buildid" && echo "no buildid result" && exit 1 + test -z "$timestamp" && echo "no timestamp result" && exit 1 + test "$buildid" -gt 0 || exit 1 + test "$timestamp" -gt 0 || exit 1 + echo "buildid and timestamp of last branch update: $buildid, $timestamp" + mkdir -p state + touch state/buildid state/timestamp + last_buildid=$(cat state/buildid) + last_timestamp=$(cat state/timestamp) + if [ -z "$last_timestamp" ]; then + echo "no stored timestamp" + last_buildid=0 + last_timestamp=0 + else + echo "stored buildid and timestamp of last branch update: $last_buildid, $last_timestamp" + fi + if [ "$buildid" -ne "$last_buildid" -a "$timestamp" -gt "$last_timestamp" ]; then + echo "branch updated" + echo "$buildid" >state/buildid + echo "$timestamp" >state/timestamp + echo BUILDID=$buildid >> $GITHUB_ENV + fi + - name: Discord Webhook Action + uses: tsickert/discord-webhook@v5.3.0 + if: env.BUILDID + with: + webhook-url: ${{ secrets.DISCORD_TEAM_PRIVATE_WEBHOOK_URL }} + content: "<@&${{ secrets.DISCORD_TEAM_ROLE_ID }}> Steam ${{ matrix.df_steam_branch }} branch updated (build id: ${{ env.BUILDID }})" + - name: Launch symbol generation workflow + if: env.BUILDID && matrix.dfhack_ref + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + gh workflow run generate-symbols.yml \ + -R DFHack/dfhack \ + -r ${{ matrix.dfhack_ref }} \ + -f structures_ref=${{ matrix.structures_ref }} \ + -f version=auto \ + -f platform=${{ matrix.platform }} \ + -f channel=steam \ + -f df_steam_branch=${{ matrix.df_steam_branch }} \ + -f steam_branch=${{ matrix.steam_branch }} + - name: Save state + uses: actions/cache/save@v4 + if: env.BUILDID + with: + path: state + key: watch-release-steam-${{ matrix.df_steam_branch }}-${{ env.BUILDID }} + + check-non-steam: + if: github.repository == 'DFHack/dfhack' + name: Check ${{ matrix.channel }} for new DF releases + runs-on: ubuntu-latest + concurrency: watch-release-${{ matrix.channel }} + strategy: + fail-fast: false + matrix: + include: + - channel: itch + url: 'https://kitfoxgames.itch.io/dwarf-fortress' + prefix: 'dwarf_fortress' + - channel: classic + url: 'https://www.bay12games.com/dwarves/' + prefix: 'df' + steps: + - name: Fetch state + uses: actions/cache/restore@v4 + with: + path: state + key: watch-release-${{ matrix.channel }} + - name: Compare versions + uses: nick-fields/retry@v3 + with: + timeout_minutes: 5 + retry_wait_seconds: 60 + command: | + version=$(wget "${{ matrix.url }}" -qO- | tr '"' '\n' | fgrep 'tar.bz2' | head -n1 | sed -r 's/${{ matrix.prefix }}_([0-9]{2})_([0-9]{2})_linux.tar.bz2/\1.\2/') + echo "latest ${{ matrix.channel }} version: $version" + if ! grep -qE '^[0-9]+\.[0-9]+$' <<<"$version"; then + echo "invalid version" + exit 1 + fi + mkdir -p state + touch state/last_version + last_version=$(cat state/last_version) + if [ -z "$last_version" ]; then + echo "no stored version" + last_version=0 + else + echo "stored ${{ matrix.channel }} version: $last_version" + fi + if [ "$(tr -d '.' <<<"$version")" -gt "$(tr -d '.' <<<"$last_version")" ]; then + echo "${{ matrix.channel }} has been updated" + echo "$version" >state/last_version + echo NEW_VERSION=$version >> $GITHUB_ENV + fi + - name: Discord Webhook Action + uses: tsickert/discord-webhook@v5.3.0 + if: env.NEW_VERSION + with: + webhook-url: ${{ secrets.DISCORD_TEAM_PRIVATE_WEBHOOK_URL }} + content: "<@&${{ secrets.DISCORD_TEAM_ROLE_ID }}> ${{ matrix.channel }} updated to ${{ env.NEW_VERSION }}" + - name: Save state + uses: actions/cache/save@v4 + if: env.NEW_VERSION + with: + path: state + key: watch-release-${{ matrix.channel }}-${{ env.NEW_VERSION }} diff --git a/.gitignore b/.gitignore index 5ef3ce7595..eda2b226d5 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,7 @@ # linux backup files *~ -#Kdevelop project files +# Kdevelop project files *.kdev4 .kdev4 @@ -9,31 +9,47 @@ build*/ nix buntu -build/VC2010 #except for the real one !build/ # Sphinx generated documentation -docs/_* +docs/changelogs/ docs/html/ +docs/pdf/ +docs/pseudoxml/ +docs/tags/ +docs/text/ +docs/tools/ +docs/xml/ # in-place build build/Makefile build/CMakeCache.txt build/cmake_install.cmake build/CMakeFiles -build/doc +build/CTestTestfile.cmake +build/DartConfiguration.tcl +build/data +build/docs build/lua build/bin +build/lib build/depends build/library +build/package build/plugins build/scripts build/install_manifest.txt build/_CPack_Packages build/dfhack-*.zip build/dfhack-*.bz2 +build/*ninja* +build/compile_commands.json +build/dfhack_setarch.txt +build/ImportExecutables.cmake +build/Testing +build/_deps # Python binding binaries *.pyc @@ -47,8 +63,27 @@ build/CPack*Config.cmake *.swp .vimrc +# VSCode files +.vscode +*.code-workspace + # ctags file tags # Mac OS X .DS_Store files .DS_Store + +# VS is annoying about this one. +/build/win64/DF_PATH.txt +/build/win32/DF_PATH.txt +/.vs + +# CLion +.idea + +# external plugins +/plugins/CMakeLists.custom.txt + +# 3rd party downloads +depends/steam +depends/SDL2 diff --git a/.gitmodules b/.gitmodules index 687dae006a..596bafc98f 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,15 +1,33 @@ [submodule "plugins/stonesense"] path = plugins/stonesense - url = git://github.com/DFHack/stonesense.git -[submodule "plugins/isoworld"] - path = plugins/isoworld - url = git://github.com/DFHack/isoworld.git + url = ../../DFHack/stonesense.git [submodule "library/xml"] path = library/xml - url = git://github.com/DFHack/df-structures.git + url = ../../DFHack/df-structures.git [submodule "depends/clsocket"] path = depends/clsocket - url = git://github.com/DFHack/clsocket.git + url = ../../DFHack/clsocket.git [submodule "scripts2"] path = scripts - url = git://github.com/dfhack/scripts.git + url = ../../DFHack/scripts.git +[submodule "depends/jsoncpp"] + path = depends/jsoncpp-sub + url = ../../DFHack/jsoncpp.git +[submodule "depends/xlsxio"] + path = depends/xlsxio + url = ../../DFHack/xlsxio.git +[submodule "depends/libzip"] + path = depends/libzip + url = ../../DFHack/libzip.git +[submodule "depends/libexpat"] + path = depends/libexpat + url = ../../DFHack/libexpat.git +[submodule "depends/luacov"] + path = depends/luacov + url = ../../DFHack/luacov.git +[submodule "depends/googletest"] + path = depends/googletest + url = ../../google/googletest.git +[submodule "depends/dfhooks"] + path = depends/dfhooks + url = ../../DFHack/dfhooks diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000000..47251d8ed3 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,44 @@ +ci: + autofix_prs: false + autoupdate_schedule: monthly +repos: +# shared across repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + - id: check-added-large-files + - id: check-case-conflict + - id: check-executables-have-shebangs + - id: check-merge-conflict + - id: check-shebang-scripts-are-executable + - id: check-symlinks + - id: check-xml + - id: check-yaml + - id: destroyed-symlinks + - id: end-of-file-fixer + - id: mixed-line-ending + args: ['--fix=lf'] + - id: trailing-whitespace +- repo: https://github.com/python-jsonschema/check-jsonschema + rev: 0.37.4 + hooks: + - id: check-github-workflows +- repo: https://github.com/Lucas-C/pre-commit-hooks + rev: v1.5.6 + hooks: + - id: forbid-tabs + exclude_types: + - json + - id: remove-tabs + exclude_types: + - json +# specific to dfhack: +- repo: local + hooks: + - id: authors-rst + name: Check Authors.rst + language: python + entry: python3 ci/authors-rst.py + files: docs/about/Authors\.rst + pass_filenames: false +exclude: '^(depends/|data/.*\.json$|.*\.diff$|.*\.dfstock$)' diff --git a/library/doc/img/.dot b/.readthedocs.requirements.txt similarity index 100% rename from library/doc/img/.dot rename to .readthedocs.requirements.txt diff --git a/.readthedocs.yml b/.readthedocs.yml new file mode 100644 index 0000000000..bf71c46b78 --- /dev/null +++ b/.readthedocs.yml @@ -0,0 +1,22 @@ +# .readthedocs.yaml +# Read the Docs configuration file +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +version: 2 + +build: + os: ubuntu-22.04 + tools: + python: "3" + +submodules: + include: all + +sphinx: + configuration: conf.py + +formats: all + +python: + install: + - requirements: .readthedocs.requirements.txt diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 1455044aa8..0000000000 --- a/.travis.yml +++ /dev/null @@ -1,50 +0,0 @@ -sudo: false -language: cpp -addons: - apt: - packages: &default_packages - - lua5.2 - - libxml-libxml-perl - - libxml-libxslt-perl - - zlib1g-dev:i386 -matrix: - include: - - env: GCC_VERSION=4.5 - addons: - apt: - packages: - - *default_packages - - gcc-4.5-multilib - - g++-4.5-multilib - - env: GCC_VERSION=4.8 - addons: - apt: - sources: - - ubuntu-toolchain-r-test - packages: - - *default_packages - - gcc-4.8-multilib - - g++-4.8-multilib -before_install: - pip install --user sphinx -script: -- git tag tmp-travis-build -- sh travis/git-info.sh -- sphinx-build -qW -j3 . docs/html -- python travis/pr-check-base.py -- python travis/lint.py -- python travis/authors-rst.py -- python travis/script-in-readme.py -- python travis/script-syntax.py --ext=lua --cmd="luac5.2 -p" -- python travis/script-syntax.py --ext=rb --cmd="ruby -c" -- mkdir build-travis -- cd build-travis -- cmake .. -DCMAKE_C_COMPILER=gcc-$GCC_VERSION -DCMAKE_CXX_COMPILER=g++-$GCC_VERSION -DBUILD_DOCS:BOOL=ON -- make -j3 -notifications: - email: false - irc: - channels: - - "chat.freenode.net#dfhack" - on_success: change - on_failure: always diff --git a/.ycm_extra_conf.py b/.ycm_extra_conf.py index a45f073725..31a336b2b6 100644 --- a/.ycm_extra_conf.py +++ b/.ycm_extra_conf.py @@ -4,12 +4,40 @@ # pylint: disable=import-error,invalid-name,missing-docstring,unused-argument -import os +import os,platform import ycm_core def DirectoryOfThisScript(): return os.path.dirname(os.path.abspath(__file__)) +default_flags = [ + '-I','library/include', + '-I','library/proto', + '-I','plugins/proto', + '-I','depends/protobuf', + '-I','depends/lua/include', + '-I','depends/md5', + '-I','depends/jsoncpp/include', + '-I','depends/tinyxml', + '-I','depends/clsocket/src', + '-x','c++', + '-D','PROTOBUF_USE_DLLS', + '-D','LUA_BUILD_AS_DLL', + '-Wall','-Wextra', +] + +if os.name == 'posix': + default_flags.extend([ + '-D','LINUX_BUILD', + '-D','_GLIBCXX_USE_C99', + ]) + if platform.system() == 'Darwin': + default_flags.extend(['-D','_DARWIN']) + else: + default_flags.extend(['-D','_LINUX']) +else: + default_flags.extend(['-D','WIN32']) + # We need to tell YouCompleteMe how to compile this project. We do this using # clang's "Compilation Database" system, which essentially just dumps a big # json file into the build folder. @@ -117,13 +145,19 @@ def FlagsForFile(filename, **kwargs): # python list, but a "list-like" StringVec object compilation_info = GetCompilationInfoForFile(filename) if not compilation_info: - return None + return { + 'flags':MakeRelativePathsInFlagsAbsolute(default_flags,DirectoryOfThisScript()), + 'do_cache': True, + } final_flags = MakeRelativePathsInFlagsAbsolute( compilation_info.compiler_flags_, compilation_info.compiler_working_dir_ ) + # Make sure ycm reports more suspicuous code lines + final_flags.append('-Wextra') + return { 'flags': final_flags, 'do_cache': True diff --git a/CMake/DownloadFile.cmake b/CMake/DownloadFile.cmake new file mode 100644 index 0000000000..d0165b11a3 --- /dev/null +++ b/CMake/DownloadFile.cmake @@ -0,0 +1,71 @@ +# Helper to download files as needed + +function(file_md5_if_exists FILE VAR) + if(EXISTS "${FILE}") + file(MD5 "${FILE}" "${VAR}") + set(${VAR} "${${VAR}}" PARENT_SCOPE) + else() + set(${VAR} "" PARENT_SCOPE) + endif() +endfunction() + +function(search_downloads FILE_MD5 VAR) + set(${VAR} "" PARENT_SCOPE) + file(GLOB FILES ${dfhack_SOURCE_DIR}/CMake/downloads/*) + foreach(FILE ${FILES}) + file(MD5 "${FILE}" CUR_MD5) + if("${CUR_MD5}" STREQUAL "${FILE_MD5}") + set(${VAR} ${FILE} PARENT_SCOPE) + return() + endif() + endforeach() +endfunction() + +function(download_file URL DEST EXPECTED_MD5) + get_filename_component(FILENAME "${URL}" NAME) + file_md5_if_exists("${DEST}" CUR_MD5) + + if(NOT "${EXPECTED_MD5}" STREQUAL "${CUR_MD5}") + search_downloads(${EXPECTED_MD5} DLPATH) + if(NOT("${DLPATH}" STREQUAL "")) + message("* Copying ${FILENAME} from ${DLPATH}") + execute_process(COMMAND "${CMAKE_COMMAND}" -E copy + "${DLPATH}" + "${DEST}") + return() + endif() + + message("* Downloading ${FILENAME}") + file(DOWNLOAD "${URL}" "${DEST}" EXPECTED_MD5 "${EXPECTED_MD5}" SHOW_PROGRESS) + endif() +endfunction() + +# Download a file and uncompress it +function(download_file_unzip URL ZIP_TYPE ZIP_DEST ZIP_MD5 UNZIP_DEST UNZIP_MD5) + get_filename_component(FILENAME "${URL}" NAME) + file_md5_if_exists("${UNZIP_DEST}" CUR_UNZIP_MD5) + + # Redownload if the MD5 of the uncompressed file doesn't match + if(NOT "${UNZIP_MD5}" STREQUAL "${CUR_UNZIP_MD5}") + download_file("${URL}" "${ZIP_DEST}" "${ZIP_MD5}") + + if(EXISTS "${ZIP_DEST}") + message("* Decompressing ${FILENAME}") + if("${ZIP_TYPE}" STREQUAL "gz") + execute_process(COMMAND + "${PERL_EXECUTABLE}" "${dfhack_SOURCE_DIR}/depends/gunzip.pl" + "${ZIP_DEST}" --force) + else() + message(SEND_ERROR "Unknown ZIP_TYPE: ${ZIP_TYPE}") + endif() + if(NOT EXISTS "${UNZIP_DEST}") + message(SEND_ERROR "File failed to unzip to ${UNZIP_DEST}") + else() + file(MD5 "${UNZIP_DEST}" CUR_UNZIP_MD5) + if(NOT "${UNZIP_MD5}" STREQUAL "${CUR_UNZIP_MD5}") + message(SEND_ERROR "MD5 mismatch: ${UNZIP_DEST}: expected ${UNZIP_MD5}, got ${CUR_UNZIP_MD5}") + endif() + endif() + endif() + endif() +endfunction() diff --git a/CMake/Modules/CMakeVS10FindMake.cmake b/CMake/Modules/CMakeVS10FindMake.cmake deleted file mode 100644 index 460de25e5d..0000000000 --- a/CMake/Modules/CMakeVS10FindMake.cmake +++ /dev/null @@ -1,28 +0,0 @@ - -#============================================================================= -# Copyright 2009 Kitware, Inc. -# -# Distributed under the OSI-approved BSD License (the "License"); -# see accompanying file Copyright.txt for details. -# -# This software is distributed WITHOUT ANY WARRANTY; without even the -# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the License for more information. -#============================================================================= -# (To distributed this file outside of CMake, substitute the full -# License text for the above reference.) - -# We use MSBuild as the build tool for VS 10 -FIND_PROGRAM(CMAKE_MAKE_PROGRAM - NAMES MSBuild - HINTS - [HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0\\Setup\\VS;ProductDir] - "$ENV{SYSTEMROOT}/Microsoft.NET/Framework/[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0;CLR Version]/" - "c:/WINDOWS/Microsoft.NET/Framework/[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0;CLR Version]/" - "$ENV{SYSTEMROOT}/Microsoft.NET/Framework/[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\10.0;CLR Version]/" - ) - -MARK_AS_ADVANCED(CMAKE_MAKE_PROGRAM) -SET(MSVC10 1) -SET(MSVC_VERSION 1600) - diff --git a/CMake/Modules/FindCurses.cmake b/CMake/Modules/FindCurses.cmake deleted file mode 100644 index 98adf9815f..0000000000 --- a/CMake/Modules/FindCurses.cmake +++ /dev/null @@ -1,23 +0,0 @@ -IF(Curses_FOUND) - SET(Curses_FIND_QUIETLY TRUE) -ENDIF() - -FIND_PATH(Curses_INCLUDE_PATH - NAMES ncurses.h curses.h - PATH_SUFFIXES ncurses - PATHS /usr/include/ncursesw /usr/include /usr/local/include /usr/pkg/include -) - -FIND_LIBRARY(Curses_LIBRARY - NAMES ncursesw - PATHS /lib /usr/lib /usr/local/lib /usr/pkg/lib -) - -IF (Curses_INCLUDE_PATH AND Curses_LIBRARY) - SET(Curses_FOUND TRUE) -ENDIF() - -MARK_AS_ADVANCED( - Curses_INCLUDE_PATH - Curses_LIBRARY -) diff --git a/CMake/Modules/FindDocutils.cmake b/CMake/Modules/FindDocutils.cmake deleted file mode 100644 index 8103628df0..0000000000 --- a/CMake/Modules/FindDocutils.cmake +++ /dev/null @@ -1,3 +0,0 @@ -FIND_PROGRAM(RST2HTML_EXECUTABLE NAMES rst2html rst2html.py) -INCLUDE(FindPackageHandleStandardArgs) -FIND_PACKAGE_HANDLE_STANDARD_ARGS(Docutils DEFAULT_MSG RST2HTML_EXECUTABLE) \ No newline at end of file diff --git a/CMake/Modules/FindDoxygen.cmake b/CMake/Modules/FindDoxygen.cmake deleted file mode 100644 index 94d20a9ffd..0000000000 --- a/CMake/Modules/FindDoxygen.cmake +++ /dev/null @@ -1,185 +0,0 @@ -# - This module looks for Doxygen and the path to Graphviz's dot -# Doxygen is a documentation generation tool. Please see -# http://www.doxygen.org -# -# This module accepts the following optional variables: -# -# DOXYGEN_SKIP_DOT = If true this module will skip trying to find Dot -# (an optional component often used by Doxygen) -# -# This modules defines the following variables: -# -# DOXYGEN_EXECUTABLE = The path to the doxygen command. -# DOXYGEN_FOUND = Was Doxygen found or not? -# -# DOXYGEN_DOT_EXECUTABLE = The path to the dot program used by doxygen. -# DOXYGEN_DOT_FOUND = Was Dot found or not? -# DOXYGEN_DOT_PATH = The path to dot not including the executable -# -# - -#Copyright 2000-2009 Kitware, Inc., Insight Software Consortium -#All rights reserved. -# -#Redistribution and use in source and binary forms, with or without -#modification, are permitted provided that the following conditions -#are met: -# -#* Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# -#* Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -#* Neither the names of Kitware, Inc., the Insight Software Consortium, -# nor the names of their contributors may be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -#THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -#"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -#LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -#A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -#HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -#SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -#LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -#DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -#THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -#(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -#OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# -#----------------------------------------------------------------------------- -# -#The above copyright and license notice applies to distributions of -#CMake in source and binary form. Some source files contain additional -#notices of original copyright by their contributors; see each source -#for details. Third-party software packages supplied with CMake under -#compatible licenses provide their own copyright notices documented in -#corresponding subdirectories. -# -#----------------------------------------------------------------------------- -# -#CMake was initially developed by Kitware with the following sponsorship: -# -# * National Library of Medicine at the National Institutes of Health -# as part of the Insight Segmentation and Registration Toolkit (ITK). -# -# * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel -# Visualization Initiative. -# -# * National Alliance for Medical Image Computing (NAMIC) is funded by the -# National Institutes of Health through the NIH Roadmap for Medical Research, -# Grant U54 EB005149. -# -# * Kitware, Inc. - - -# For backwards compatibility support -IF(Doxygen_FIND_QUIETLY) - SET(DOXYGEN_FIND_QUIETLY TRUE) -ENDIF(Doxygen_FIND_QUIETLY) - -# ===== Rationale for OS X AppBundle mods below ===== -# With the OS X GUI version, Doxygen likes to be installed to /Applications and -# it contains the doxygen executable in the bundle. In the versions I've -# seen, it is located in Resources, but in general, more often binaries are -# located in MacOS. -# -# NOTE: The official Doxygen.app that is distributed for OS X uses non-standard -# conventions. Instead of the command-line "doxygen" tool being placed in -# Doxygen.app/Contents/MacOS, "Doxywizard" is placed there instead and -# "doxygen" is placed in Contents/Resources. This is most likely done -# so that something happens when people double-click on the Doxygen.app -# package. Unfortunately, CMake gets confused by this as when it sees the -# bundle it uses "Doxywizard" as the executable to use instead of -# "doxygen". Therefore to work-around this issue we temporarily disable -# the app-bundle feature, just for this CMake module: -if(APPLE) - # Save the old setting - SET(TEMP_DOXYGEN_SAVE_CMAKE_FIND_APPBUNDLE ${CMAKE_FIND_APPBUNDLE}) - # Disable the App-bundle detection feature - SET(CMAKE_FIND_APPBUNDLE "NEVER") -endif() -# FYI: -# In the older versions of OS X Doxygen, dot was included with the -# Doxygen bundle. But the new versions require you to download -# Graphviz.app which contains "dot" in it's bundle. -# ============== End OSX stuff ================ - -# -# Find Doxygen... -# - -FIND_PROGRAM(DOXYGEN_EXECUTABLE - NAMES doxygen - PATHS - "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\doxygen_is1;Inno Setup: App Path]/bin" - /Applications/Doxygen.app/Contents/Resources - /Applications/Doxygen.app/Contents/MacOS - DOC "Doxygen documentation generation tool (http://www.doxygen.org)" -) - -include(FindPackageHandleStandardArgs) -FIND_PACKAGE_HANDLE_STANDARD_ARGS(Doxygen DEFAULT_MSG DOXYGEN_EXECUTABLE) - -# -# Find Dot... -# - -IF(NOT DOXYGEN_SKIP_DOT) - FIND_PROGRAM(DOXYGEN_DOT_EXECUTABLE - NAMES dot - PATHS - "$ENV{ProgramFiles}/Graphviz2.26.3/bin" - "C:/Program Files/Graphviz2.26.3/bin" - "$ENV{ProgramFiles}/Graphviz 2.21/bin" - "C:/Program Files/Graphviz 2.21/bin" - "$ENV{ProgramFiles}/ATT/Graphviz/bin" - "C:/Program Files/ATT/Graphviz/bin" - [HKEY_LOCAL_MACHINE\\SOFTWARE\\ATT\\Graphviz;InstallPath]/bin - /Applications/Graphviz.app/Contents/MacOS - /Applications/Doxygen.app/Contents/Resources - /Applications/Doxygen.app/Contents/MacOS - DOC "Graphviz Dot tool for using Doxygen" - ) - - if(DOXYGEN_DOT_EXECUTABLE) - set(DOXYGEN_DOT_FOUND TRUE) - # The Doxyfile wants the path to Dot, not the entire path and executable - get_filename_component(DOXYGEN_DOT_PATH "${DOXYGEN_DOT_EXECUTABLE}" PATH CACHE) - endif() - -endif(NOT DOXYGEN_SKIP_DOT) - -# -# Backwards compatibility... -# - -if(APPLE) - # Restore the old app-bundle setting setting - SET(CMAKE_FIND_APPBUNDLE ${TEMP_DOXYGEN_SAVE_CMAKE_FIND_APPBUNDLE}) -endif() - -# Maintain the _FOUND variables as "YES" or "NO" for backwards compatibility -# (allows people to stuff them directly into Doxyfile with configure_file()) -if(DOXYGEN_FOUND) - set(DOXYGEN_FOUND "YES") -else() - set(DOXYGEN_FOUND "NO") -endif() -if(DOXYGEN_DOT_FOUND) - set(DOXYGEN_DOT_FOUND "YES") -else() - set(DOXYGEN_DOT_FOUND "NO") -endif() - -# For backwards compatibility support -SET (DOXYGEN ${DOXYGEN_EXECUTABLE} ) -SET (DOT ${DOXYGEN_DOT_EXECUTABLE} ) - -MARK_AS_ADVANCED( - DOXYGEN_EXECUTABLE - DOXYGEN_DOT_EXECUTABLE - DOXYGEN_DOT_PATH - ) diff --git a/CMake/Modules/FindSphinx.cmake b/CMake/Modules/FindSphinx.cmake index 54fc5ea8dc..6b78a555ff 100644 --- a/CMake/Modules/FindSphinx.cmake +++ b/CMake/Modules/FindSphinx.cmake @@ -13,4 +13,3 @@ find_package_handle_standard_args(Sphinx DEFAULT_MSG ) mark_as_advanced(SPHINX_EXECUTABLE) - diff --git a/CMake/Modules/FindTinyXML.cmake b/CMake/Modules/FindTinyXML.cmake index b0466fbd54..4d6d69f7bb 100644 --- a/CMake/Modules/FindTinyXML.cmake +++ b/CMake/Modules/FindTinyXML.cmake @@ -32,11 +32,11 @@ # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ################################################################################################## -# +# # CMake script for finding TinyXML. -# +# # Input variables: -# +# # - TinyXML_ROOT_DIR (optional): When specified, header files and libraries will be searched for in # ${TinyXML_ROOT_DIR}/include # ${TinyXML_ROOT_DIR}/libs @@ -46,23 +46,23 @@ # preference is given to the CMake variable. # Use this variable for finding packages installed in a nonstandard location, or for enforcing # that one of multiple package installations is picked up. -# -# +# +# # Cache variables (not intended to be used in CMakeLists.txt files) -# +# # - TinyXML_INCLUDE_DIR: Absolute path to package headers. # - TinyXML_LIBRARY: Absolute path to library. -# -# +# +# # Output variables: -# +# # - TinyXML_FOUND: Boolean that indicates if the package was found # - TinyXML_INCLUDE_DIRS: Paths to the necessary header files # - TinyXML_LIBRARIES: Package libraries -# -# +# +# # Example usage: -# +# # find_package(TinyXML) # if(NOT TinyXML_FOUND) # # Error handling @@ -71,19 +71,19 @@ # include_directories(${TinyXML_INCLUDE_DIRS} ...) # ... # target_link_libraries(my_target ${TinyXML_LIBRARIES}) -# +# ################################################################################################## # Get package location hint from environment variable (if any) if(NOT TinyXML_ROOT_DIR AND DEFINED ENV{TinyXML_ROOT_DIR}) - set(TinyXML_ROOT_DIR "$ENV{TinyXML_ROOT_DIR}" CACHE PATH - "TinyXML base directory location (optional, used for nonstandard installation paths)") + set(TinyXML_ROOT_DIR "$ENV{TinyXML_ROOT_DIR}" CACHE PATH + "TinyXML base directory location (optional, used for nonstandard installation paths)") endif() # Search path for nonstandard package locations if(TinyXML_ROOT_DIR) - set(TinyXML_INCLUDE_PATH PATHS "${TinyXML_ROOT_DIR}/include" NO_DEFAULT_PATH) - set(TinyXML_LIBRARY_PATH PATHS "${TinyXML_ROOT_DIR}/lib" NO_DEFAULT_PATH) + set(TinyXML_INCLUDE_PATH PATHS "${TinyXML_ROOT_DIR}/include" NO_DEFAULT_PATH) + set(TinyXML_LIBRARY_PATH PATHS "${TinyXML_ROOT_DIR}/lib" NO_DEFAULT_PATH) endif() # Find headers and libraries @@ -102,6 +102,6 @@ set(TinyXML_FOUND ${TINYXML_FOUND}) # Enforce case-correctness: Set appropriatel unset(TINYXML_FOUND) # ...and unset uppercase variable generated by find_package_handle_standard_args if(TinyXML_FOUND) - set(TinyXML_INCLUDE_DIRS ${TinyXML_INCLUDE_DIR}) - set(TinyXML_LIBRARIES ${TinyXML_LIBRARY}) + set(TinyXML_INCLUDE_DIRS ${TinyXML_INCLUDE_DIR}) + set(TinyXML_LIBRARIES ${TinyXML_LIBRARY}) endif() diff --git a/CMake/downloads/.gitignore b/CMake/downloads/.gitignore new file mode 100644 index 0000000000..ff7b252fea --- /dev/null +++ b/CMake/downloads/.gitignore @@ -0,0 +1,3 @@ +* +!README.txt +!.gitignore diff --git a/CMake/downloads/README.txt b/CMake/downloads/README.txt new file mode 100644 index 0000000000..40b5047257 --- /dev/null +++ b/CMake/downloads/README.txt @@ -0,0 +1,3 @@ +This folder exists as an alternate location for downloaded files. Files will +ordinarily not be downloaded here, but CMake will look for them here anyway to +facilitate offline builds. diff --git a/CMakeLists.txt b/CMakeLists.txt index 10a831c28a..1495bea2b1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,168 +1,295 @@ # main project file. use it from a build sub-folder, see COMPILE for details -# prevent CMake warnings about INTERFACE_LINK_LIBRARIES vs LINK_INTERFACE_LIBRARIES -IF(CMAKE_VERSION VERSION_GREATER "2.8.12") - CMAKE_POLICY(SET CMP0022 OLD) -ENDIF() +## some generic CMake magic +cmake_minimum_required(VERSION 3.18 FATAL_ERROR) +cmake_policy(SET CMP0048 NEW) +cmake_policy(SET CMP0074 NEW) +set(CMAKE_INSTALL_MESSAGE "LAZY") + +# set up versioning. +set(DF_VERSION "53.16") +set(DFHACK_RELEASE "r1.1") +set(DFHACK_PRERELEASE FALSE) + +set(DFHACK_VERSION "${DF_VERSION}-${DFHACK_RELEASE}") +set(DFHACK_ABI_VERSION 2) +set(DFHACK_BUILD_ID "" CACHE STRING "Build ID (should be specified on command line)") + +# set up ccache +find_program(CCACHE_EXECUTABLE "ccache" HINTS /usr/local/bin /opt/local/bin) +if(CCACHE_EXECUTABLE) + message(STATUS "using ccache") + set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE) + set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE) +endif() + +# project must be declared *after* ccache setup +project(dfhack) # Set up build types if(CMAKE_CONFIGURATION_TYPES) - SET(CMAKE_CONFIGURATION_TYPES Release RelWithDebInfo) - SET(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING "List of supported configuration types" FORCE) + set(CMAKE_CONFIGURATION_TYPES "Release;RelWithDebInfo" CACHE STRING "List of supported configuration types" FORCE) else(CMAKE_CONFIGURATION_TYPES) - if (NOT CMAKE_BUILD_TYPE) - SET(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Release RelWithDebInfo.") - endif (NOT CMAKE_BUILD_TYPE) + set(DFHACK_TYPE_HELP "Choose the type of build, options are: Release and RelWithDebInfo") + # Prevent cmake C module attempts to overwrite our help string + if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "Release" CACHE STRING "${DFHACK_TYPE_HELP}") + else(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING "${DFHACK_TYPE_HELP}") + endif(NOT CMAKE_BUILD_TYPE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Release;RelWithDebInfo") endif(CMAKE_CONFIGURATION_TYPES) -OPTION(BUILD_DOCS "Choose whether to build the documentation (requires python and Sphinx)." OFF) - -## some generic CMake magic -cmake_minimum_required(VERSION 2.8 FATAL_ERROR) -project(dfhack) +option(BUILD_DOCS "Choose whether to build the documentation (requires python and Sphinx)." OFF) +option(BUILD_DOCS_NO_HTML "Don't build the HTML docs, only the in-game docs." OFF) +option(REMOVE_SYMBOLS_FROM_DF_STUBS "Remove debug symbols from DF stubs. (Reduces libdfhack size to about half but removes a few useful symbols)" ON) -macro(CHECK_GCC COMPILER_PATH) - execute_process(COMMAND ${COMPILER_PATH} -dumpversion OUTPUT_VARIABLE GCC_VERSION_OUT) - string(STRIP "${GCC_VERSION_OUT}" GCC_VERSION_OUT) - if (${GCC_VERSION_OUT} VERSION_LESS "4.5") - message(SEND_ERROR "${COMPILER_PATH} version ${GCC_VERSION_OUT} cannot be used - use GCC 4.5 or later") - elseif (${GCC_VERSION_OUT} VERSION_GREATER "4.9.9") - # GCC 5 changes ABI name mangling to enable C++11 changes. - # This must be disabled to enable linking against DF. - # http://developerblog.redhat.com/2015/02/05/gcc5-and-the-c11-abi/ - add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0) - endif() +macro(CHECK_GCC compiler_path) + execute_process(COMMAND ${compiler_path} -dumpversion OUTPUT_VARIABLE GCC_VERSION_OUT) + string(STRIP "${GCC_VERSION_OUT}" GCC_VERSION_OUT) + if(${GCC_VERSION_OUT} VERSION_LESS "11") + message(SEND_ERROR "${compiler_path} version ${GCC_VERSION_OUT} cannot be used - use GCC 11 or later") + endif() + # GCC 16 currently has a defect that prevents it from compiling DFHack + # -Warray-bounds is broken in GCC 16 and we'd rather disable the compiler than remove this warning + # will reconsider when this defect is fixed in a future GCC release + if(${GCC_VERSION_OUT} VERSION_GREATER_EQUAL "16") + message(SEND_ERROR "${compiler_path} version ${GCC_VERSION_OUT} cannot be used - use GCC 15 or earlier") + endif() endmacro() if(UNIX) - if(CMAKE_COMPILER_IS_GNUCC) - CHECK_GCC(${CMAKE_C_COMPILER}) - else() - message(SEND_ERROR "C compiler is not GCC") - endif() - if(CMAKE_COMPILER_IS_GNUCXX) - CHECK_GCC(${CMAKE_CXX_COMPILER}) - else() - message(SEND_ERROR "C++ compiler is not GCC") - endif() + if(CMAKE_COMPILER_IS_GNUCC) + check_gcc(${CMAKE_C_COMPILER}) + else() + message(SEND_ERROR "C compiler is not GCC") + endif() + if(CMAKE_COMPILER_IS_GNUCXX) + check_gcc(${CMAKE_CXX_COMPILER}) + else() + message(SEND_ERROR "C++ compiler is not GCC") + endif() endif() if(WIN32) - if((NOT MSVC) OR (NOT MSVC_VERSION STREQUAL 1600)) - message(SEND_ERROR "MSVC 2010 is required") - endif() + set(MSVC_MIN_VER 1930) + set(MSVC_MAX_VER 1944) + if(NOT MSVC) + message(SEND_ERROR "No MSVC found! MSVC 2022 version ${MSVC_MIN_VER} to ${MSVC_MAX_VER} is required.") + elseif((MSVC_VERSION LESS MSVC_MIN_VER) OR (MSVC_VERSION GREATER MSVC_MAX_VER)) + message(SEND_ERROR "MSVC 2022 version ${MSVC_MIN_VER} to ${MSVC_MAX_VER} is required, Version Found: ${MSVC_VERSION}") + endif() endif() +# Ask for C++-20 standard from compilers +set(CMAKE_CXX_STANDARD 20) +# Require the standard support from compilers. +set(CMAKE_CXX_STANDARD_REQUIRED ON) +# Use only standard c++ to keep code portable +set(CMAKE_CXX_EXTENSIONS OFF) + if(MSVC) -# disable C4819 code-page warning -add_definitions( "/wd4819" ) + # increase warning level and treat warnings as errors + add_compile_options("/WX") + add_compile_options("/W3") + + # disable C4819 code-page warning + add_compile_options("/wd4819") + + # disable use of POSIX name warnings + add_definitions("/D_CRT_NONSTDC_NO_WARNINGS /D_CRT_SECURE_NO_WARNINGS") + + # supress C4503 - VC++ dislikes if a name is too long. If you get + # weird and mysterious linking errors, you can disable this, but you'll have to + # deal with a LOT of compiler noise over it + # see https://msdn.microsoft.com/en-us/library/074af4b6.aspx + add_compile_options("/wd4503") + + # suppress C4267 - VC++ considers a narrowing conversion from size_t to a smaller + # integer type a warning. this is technically correct but there are so many instances + # of this that we don't want to fix, so.... + add_compile_options("/wd4267") + + # suppress C4251 - VC++ will warn when exporting an entire class which contains members + # referencing unexported compound types as this is potentially unsafe. because we don't + # guarantee a stable ABI for exports, we don't really care about this, and so we choose to + # be lazy and continue to export entire classes instead of exporting on a method-by-method basis + add_compile_options("/wd4251") + + # suppress C4068 - VC++ will warn for unknown pragmas by default. this is equivalent to gcc + # -Wno-unknown-pragmas (which is enabled for gcc below). + # we could work around this with sufficiently complex macros + add_compile_options("/wd4068") + + # suppress C4244 - VC++ warns by default (with /W3) about narrowing conversions that may lose data + # (such as double -> int or int32_t -> int16_t). dfhack has many of these, mostly related to Lua + # this is equivalent to gcc -Wno_conversions which is the default as gcc -Wall doesn't enable -Wconversions + add_compile_options("/wd4244") + + # Enable C5038 - This is equivalent to gcc's -Werror=reorder, which is enabled by default by gcc -Wall + add_compile_options("/w15038") + + # Enable C4062 - Warns about missing enum case in switch statement, equivalent to gcc -Wswitch + add_compile_options("/w14062") + + # MSVC panics if an object file contains more than 65,279 sections. this + # happens quite frequently with code that uses templates, such as vectors. + add_compile_options("/bigobj") endif() -IF(CMAKE_CROSSCOMPILING) - SET(DFHACK_NATIVE_BUILD_DIR "DFHACK_NATIVE_BUILD_DIR-NOTFOUND" CACHE FILEPATH "Path to a native build directory") - INCLUDE("${DFHACK_NATIVE_BUILD_DIR}/ImportExecutables.cmake") -ENDIF() +# Automatically detect architecture based on Visual Studio generator +if(MSVC AND NOT DEFINED DFHACK_BUILD_ARCH) + if ((${CMAKE_GENERATOR} MATCHES "Win32") OR (${CMAKE_GENERATOR} MATCHES "x86")) + message(SEND_ERROR "DF v50 does not support 32-bit") + else() + set(DFHACK_BUILD_ARCH "64") + endif() +else() + set(DFHACK_BUILD_ARCH "64" CACHE STRING "Architecture to build ('32' or '64')") +endif() -# set up folder structures for IDE solutions -# MSVC Express won't load solutions that use this. It also doesn't include MFC supported -# Check for MFC! -find_package(MFC QUIET) -if(MFC_FOUND OR (NOT MSVC)) - OPTION(CMAKE_USE_FOLDERS "Enable folder grouping of projects in IDEs." ON) +if("${DFHACK_BUILD_ARCH}" STREQUAL "32") + set(DFHACK_BUILD_32 1) + set(DFHACK_BUILD_64 0) + set(DFHACK_SETARCH "i386") +elseif("${DFHACK_BUILD_ARCH}" STREQUAL "64") + set(DFHACK_BUILD_32 0) + set(DFHACK_BUILD_64 1) + set(DFHACK_SETARCH "x86_64") + add_definitions(-DDFHACK64) else() - OPTION(CMAKE_USE_FOLDERS "Enable folder grouping of projects in IDEs." OFF) + message(SEND_ERROR "Invalid build architecture (should be 32 or 64): ${DFHACK_BUILD_ARCH}") endif() +if(CMAKE_CROSSCOMPILING) + set(DFHACK_NATIVE_BUILD_DIR "DFHACK_NATIVE_BUILD_DIR-NOTFOUND" CACHE FILEPATH "Path to a native build directory") + include("${DFHACK_NATIVE_BUILD_DIR}/ImportExecutables.cmake") +endif() + +find_package(Perl REQUIRED) + +# set up folder structures for IDE solutions +# checking for msvc express is meaningless now, all available editions of msvc support folder groupings +option(CMAKE_USE_FOLDERS "Enable folder grouping of projects in IDEs." ON) + if(CMAKE_USE_FOLDERS) - SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS ON) + set_property(GLOBAL PROPERTY USE_FOLDERS ON) else() - SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS OFF) + set_property(GLOBAL PROPERTY USE_FOLDERS OFF) endif() -# macro for setting up IDE folders without nasty IF()s everywhere -MACRO(IDE_FOLDER target folder) +# macro for setting up IDE folders without nasty if()s everywhere +macro(IDE_FOLDER target folder) if(CMAKE_USE_FOLDERS) - SET_PROPERTY(TARGET ${target} PROPERTY FOLDER ${folder}) + set_property(TARGET ${target} PROPERTY FOLDER ${folder}) endif() -ENDMACRO() +endmacro() -SET(CMAKE_MODULE_PATH -${dfhack_SOURCE_DIR}/CMake/Modules -${CMAKE_MODULE_PATH} +set(CMAKE_MODULE_PATH + ${dfhack_SOURCE_DIR}/CMake/Modules + ${CMAKE_MODULE_PATH} ) # generates compile_commands.json, used for autocompletion by some editors -SET(CMAKE_EXPORT_COMPILE_COMMANDS ON) +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +include(CheckCXXSourceCompiles) +check_cxx_source_compiles(" +#include +#include +int main(void) { + char32_t in = 0; + char out[MB_CUR_MAX]; + std::mbstate_t state{}; + std::c32rtomb(out, in, &state); + return 0; +}" HAVE_CUCHAR2) +if(HAVE_CUCHAR2) + add_definitions("-DHAVE_CUCHAR") +endif() # mixing the build system with the source code is ugly and stupid. enforce the opposite :) -if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}") - message(FATAL_ERROR "In-source builds are not allowed.") +if("${dfhack_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}") + message(FATAL_ERROR "In-source builds are not allowed.") endif() # make sure all the necessary submodules have been set up -if (NOT EXISTS ${dfhack_SOURCE_DIR}/library/xml/codegen.pl OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/clsocket/CMakeLists.txt) - message(SEND_ERROR "One or more required submodules could not be found! Run 'git submodule update --init' from the root DFHack directory. (See the section 'Getting the Code' in docs/Compile.rst)") +if(NOT EXISTS ${dfhack_SOURCE_DIR}/library/xml/codegen.pl + OR NOT EXISTS ${dfhack_SOURCE_DIR}/scripts/CMakeLists.txt + OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/dfhooks/CMakeLists.txt + OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/clsocket/CMakeLists.txt + OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/jsoncpp-sub/CMakeLists.txt + OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/libexpat/expat/CMakeLists.txt + OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/libzip/CMakeLists.txt + OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/xlsxio/CMakeLists.txt + OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/googletest/CMakeLists.txt + OR NOT EXISTS ${dfhack_SOURCE_DIR}/depends/luacov/src +) + message(SEND_ERROR "One or more required submodules could not be found! Run 'git submodule update --init' from the root DFHack directory. (See the section 'Getting the Code' in docs/dev/compile/Compile.rst)") endif() -# set up versioning. -set(DF_VERSION "0.43.03") -SET(DFHACK_RELEASE "r1") -SET(DFHACK_PRERELEASE FALSE) - -set(DFHACK_VERSION "${DF_VERSION}-${DFHACK_RELEASE}") +# dfhack data goes here: +set(DFHACK_DATA_DESTINATION hack) ## where to install things (after the build is done, classic 'make install' or package structure) # the dfhack libraries will be installed here: -IF(UNIX) - # put the lib into DF/hack - SET(DFHACK_LIBRARY_DESTINATION hack) - SET(DFHACK_EGGY_DESTINATION libs) -ELSE() - # windows is crap, therefore we can't do nice things with it. leave the libs on a nasty pile... - SET(DFHACK_LIBRARY_DESTINATION .) - SET(DFHACK_EGGY_DESTINATION .) -ENDIF() + +# put the lib into DF/hack +# windows will find it because dfhooks will `AddDllDirectory` the hack folder at runtime +set(DFHACK_LIBRARY_DESTINATION ${DFHACK_DATA_DESTINATION}) + # external tools will be installed here: -SET(DFHACK_BINARY_DESTINATION .) -# dfhack data goes here: -SET(DFHACK_DATA_DESTINATION hack) +set(DFHACK_BINARY_DESTINATION .) # plugin libs go here: -SET(DFHACK_PLUGIN_DESTINATION hack/plugins) -# dfhack header files go here: -SET(DFHACK_INCLUDES_DESTINATION hack/include) +set(DFHACK_PLUGIN_DESTINATION ${DFHACK_DATA_DESTINATION}/plugins) # dfhack lua files go here: -SET(DFHACK_LUA_DESTINATION hack/lua) -# the windows .lib file goes here: -SET(DFHACK_DEVLIB_DESTINATION hack) +set(DFHACK_LUA_DESTINATION ${DFHACK_DATA_DESTINATION}/lua) # user documentation goes here: -SET(DFHACK_USERDOC_DESTINATION hack) -# developer documentation goes here: -SET(DFHACK_DEVDOC_DESTINATION hack) - -## some options for the user/developer to play with -OPTION(BUILD_LIBRARY "Build the library that goes into DF." ON) -OPTION(BUILD_PLUGINS "Build the plugins." ON) - -IF(UNIX) - ## flags for GCC - # default to hidden symbols - # build 32bit - # ensure compatibility with older CPUs - # enable C++11 features - add_definitions(-DLINUX_BUILD) - SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -g -Wall -Wno-unused-variable") - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -m32 -march=i686 -mtune=generic -std=c++0x") - SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden -m32 -march=i686 -mtune=generic") -ELSEIF(MSVC) - # for msvc, tell it to always use 8-byte pointers to member functions to avoid confusion - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /vmg /vmm /MP") - SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Od") -ENDIF() +set(DFHACK_USERDOC_DESTINATION ${DFHACK_DATA_DESTINATION}) + +# some options for the user/developer to play with +option(BUILD_LIBRARY "Build the DFHack library." ON) +option(BUILD_PLUGINS "Build the DFHack plugins." ON) +option(INSTALL_SCRIPTS "Install DFHack scripts." ON) +option(INSTALL_DATA_FILES "Install DFHack platform independent files." ON) + +set(CMAKE_POSITION_INDEPENDENT_CODE TRUE) +if(UNIX) + ## flags for GCC + # default to hidden symbols + # ensure compatibility with older CPUs + add_definitions(-DLINUX_BUILD) + set(GCC_COMMON_FLAGS "-fvisibility=hidden -mtune=generic -Wall -Werror -Wl,--disable-new-dtags -Wno-unknown-pragmas") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_COMMON_FLAGS}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GCC_COMMON_FLAGS}") + if(DFHACK_BUILD_64) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64 -mno-avx") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m64 -mno-avx") + else() + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32 -march=i686") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32 -march=i686") + endif() + string(REPLACE "-DNDEBUG" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") + set(CMAKE_INSTALL_RPATH "$ORIGIN") +elseif(MSVC) + # for msvc, tell it to always use 8-byte pointers to member functions to avoid confusion + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /vmg /vmm /MP") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Od") + string(REPLACE "/O2" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") + string(REPLACE "/DNDEBUG" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") + + option(BUILD_PDBS "Build PDB debug symbol files." OFF) + if(BUILD_PDBS) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Z7") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG") + set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /DEBUG") + endif() +endif() # use shared libraries for protobuf -ADD_DEFINITIONS(-DPROTOBUF_USE_DLLS) -ADD_DEFINITIONS(-DLUA_BUILD_AS_DLL) +add_definitions(-DPROTOBUF_USE_DLLS) +add_definitions(-DLUA_BUILD_AS_DLL) if(APPLE) add_definitions(-D_DARWIN) @@ -173,19 +300,125 @@ elseif(WIN32) add_definitions(-DWIN32) endif() -#### expose depends #### +#### dependencies #### + +# fix for pyenv: default to `python3` before `python3.x` +set(Python_FIND_UNVERSIONED_NAMES FIRST) -# find and make available libz -if(NOT UNIX) - SET(ZLIB_ROOT depends/zlib/) +include(CMake/DownloadFile.cmake) + +if(WIN32) + set(ZLIB_FILE zlib.lib) + set(ZLIB_PATH ${dfhack_SOURCE_DIR}/depends/zlib/) + set(ZLIB_MD5 a3b2fc6b68efafa89b0882e354fc8418) + download_file("https://github.com/DFHack/dfhack-bin/releases/download/0.44.09/win64-${ZLIB_FILE}" + ${ZLIB_PATH}lib/${ZLIB_FILE} + ${ZLIB_MD5}) + set(ZLIB_ROOT ${ZLIB_PATH}) else() - set(ZLIB_ROOT /usr/lib/i386-linux-gnu) + # Rescan for pthread and zlib if the build arch changed + if(NOT "${DFHACK_BUILD_ARCH}" STREQUAL "${DFHACK_BUILD_ARCH_PREV}") + unset(ZLIB_LIBRARY CACHE) + unset(CMAKE_HAVE_PTHREAD_H CACHE) + endif() + + if(NOT APPLE AND DFHACK_BUILD_32) + set(ZLIB_ROOT /usr/lib/i386-linux-gnu) + endif() endif() find_package(ZLIB REQUIRED) -include_directories(depends/protobuf) -include_directories(depends/lua/include) -include_directories(depends/md5) -include_directories(depends/jsoncpp) + +set(USE_SYSTEM_SDL2 OFF CACHE BOOL "Set to ON to use the system SDL2 headers.") + +if(BUILD_LIBRARY) + if(USE_SYSTEM_SDL2) + find_package(SDL2 REQUIRED CONFIG REQUIRED COMPONENTS SDL2) + else() + # Download SDL release and extract into depends in the build dir + # all we need are the header files (including generated headers), so the same release package + # will work for all platforms + # (the above statement is untested for OSX) + set(SDL_VERSION 2.26.2) + set(SDL_ZIP_MD5 574daf26d48de753d0b1e19823c9d8bb) + set(SDL_ZIP_FILE SDL2-devel-${SDL_VERSION}-VC.zip) + set(SDL_ZIP_PATH ${dfhack_SOURCE_DIR}/depends/SDL2/) + download_file("https://github.com/libsdl-org/SDL/releases/download/release-${SDL_VERSION}/${SDL_ZIP_FILE}" + ${SDL_ZIP_PATH}${SDL_ZIP_FILE} + ${SDL_ZIP_MD5}) + file(ARCHIVE_EXTRACT INPUT ${SDL_ZIP_PATH}${SDL_ZIP_FILE} + DESTINATION ${SDL_ZIP_PATH}) + set(SDL2_INCLUDE_DIRS ${SDL_ZIP_PATH}/SDL2-${SDL_VERSION}/include) + endif() +endif() + +# this can be made conditional once we get to better platform support for std::format +INCLUDE(FetchContent) +FetchContent_Declare( + fmt + GIT_REPOSITORY https://github.com/fmtlib/fmt.git + GIT_TAG 790b9389ae99c4ddebdd2736a8602eca1fec684e # 12.1.0 + bugfix for MSVC warning + build time improvements +) +FetchContent_MakeAvailable(fmt) +set(FMTLIB fmt) +add_definitions("-DUSE_FMTLIB") + +if(APPLE) + # libstdc++ (GCC 4.8.5 for OS X 10.6) + # fixes crash-on-unwind bug in DF's libstdc++ + set(LIBSTDCXX_DOWNLOAD_DIR ${dfhack_SOURCE_DIR}/package/darwin/osx${DFHACK_BUILD_ARCH}) + + if(${GCC_VERSION_OUT} VERSION_LESS "4.9") + set(LIBSTDCXX_GCC_VER "48") + else() + set(LIBSTDCXX_GCC_VER "7") + set(LIBSTDCXX_DOWNLOAD_DIR "${LIBSTDCXX_DOWNLOAD_DIR}-gcc7") + endif() + + if(${DFHACK_BUILD_ARCH} STREQUAL "64") + if(${LIBSTDCXX_GCC_VER} STREQUAL "48") + download_file_unzip("https://github.com/DFHack/dfhack-bin/releases/download/0.44.09/osx64-gcc48-libstdcxx.6.dylib.gz" + "gz" + ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib.gz + "cf26ed588be8e83c8e3a49919793b416" + ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib + "16dc6dbd4ecde7f9b95bb6dc91f07404") + else() + # GCC 7 + download_file_unzip("https://github.com/DFHack/dfhack-bin/releases/download/0.44.09/osx64-gcc7-libstdcxx.6.dylib.gz" + "gz" + ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib.gz + "81314b7846f9e8806409bef2160c76e6" + ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib + "93b6cf4b01e9a9084a508fd6a4a88992") + endif() + + else() # 32-bit + + if(${LIBSTDCXX_GCC_VER} STREQUAL "48") + download_file_unzip("https://github.com/DFHack/dfhack-bin/releases/download/0.44.09/osx32-gcc48-libstdcxx.6.dylib.gz" + "gz" + ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib.gz + "40f3d83871b114f0279240626311621b" + ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib + "c3f5678b8204917e03870834902c3e8b") + else() + # GCC 7 + download_file_unzip("https://github.com/DFHack/dfhack-bin/releases/download/0.44.09/osx32-gcc7-libstdcxx.6.dylib.gz" + "gz" + ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib.gz + "dbd213171f66edb90d204d525f10c969" + ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib + "b14c857e7e485a097c70a9ccd3132da7") + endif() + endif() + + if(NOT EXTERNAL_LIBSTDCXX) + install(PROGRAMS ${LIBSTDCXX_DOWNLOAD_DIR}/libstdc++.6.dylib + DESTINATION ./hack/) + endif() +endif() + +#### expose depends #### # Support linking against external tinyxml # If we find an external tinyxml, set the DFHACK_TINYXML variable to "tinyxml" @@ -196,16 +429,25 @@ if(EXTERNAL_TINYXML) if(NOT TinyXML_FOUND) message(SEND_ERROR "Could not find an external TinyXML, consider setting EXTERNAL_TINYXML to OFF.") endif() - SET(DFHACK_TINYXML "tinyxml") + set(DFHACK_TINYXML "tinyxml") else() - include_directories(depends/tinyxml) - SET(DFHACK_TINYXML "dfhack-tinyxml") + set(DFHACK_TINYXML "dfhack-tinyxml") endif() -include_directories(depends/tthread) -include_directories(${ZLIB_INCLUDE_DIRS}) -include_directories(depends/clsocket/src) -add_subdirectory(depends) +if(BUILD_LIBRARY) + add_subdirectory(depends) +endif() + +# Testing with CTest +macro(dfhack_test name files) +if(BUILD_LIBRARY AND UNIX AND NOT APPLE) # remove this once our MSVC build env has been updated + add_executable(${name} ${files}) + target_include_directories(${name} PUBLIC depends/googletest/googletest/include) + target_link_libraries(${name} dfhack ${FMTLIB} gtest) + add_test(NAME ${name} COMMAND ${name}) +endif() +endmacro() +include(CTest) find_package(Git REQUIRED) if(NOT GIT_FOUND) @@ -213,92 +455,198 @@ if(NOT GIT_FOUND) endif() # build the lib itself -IF(BUILD_LIBRARY) - add_subdirectory (library) - install(FILES LICENSE.rst NEWS.rst DESTINATION ${DFHACK_USERDOC_DESTINATION}) +add_subdirectory(library) +if(BUILD_LIBRARY) + file(WRITE ${CMAKE_BINARY_DIR}/dfhack_setarch.txt ${DFHACK_SETARCH}) + install(FILES ${CMAKE_BINARY_DIR}/dfhack_setarch.txt DESTINATION ${DFHACK_DATA_DESTINATION}) endif() -install(DIRECTORY dfhack-config/ DESTINATION dfhack-config/default) +# build the plugins +add_subdirectory(plugins) -#build the plugins -IF(BUILD_PLUGINS) - add_subdirectory (plugins) +if(INSTALL_DATA_FILES) + add_subdirectory(data) + install(FILES LICENSE.rst DESTINATION ${DFHACK_USERDOC_DESTINATION}) + install(FILES docs/changelog-placeholder.txt DESTINATION ${DFHACK_USERDOC_DESTINATION} RENAME changelog.txt) + install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/depends/luacov/src/luacov/ DESTINATION ${DFHACK_DATA_DESTINATION}/lua/luacov) endif() -add_subdirectory(scripts) - -find_package(Sphinx QUIET) -if (BUILD_DOCS) - if (NOT SPHINX_FOUND) - message(SEND_ERROR "Sphinx not found but BUILD_DOCS enabled") - endif() - - file(GLOB SPHINX_DEPS - "${CMAKE_CURRENT_SOURCE_DIR}/docs/*.rst" - "${CMAKE_CURRENT_SOURCE_DIR}/docs/images/*.png" - "${CMAKE_CURRENT_SOURCE_DIR}/docs/styles/*" - "${CMAKE_CURRENT_SOURCE_DIR}/conf.py" - "${CMAKE_CURRENT_SOURCE_DIR}/scripts/about.txt" - "${CMAKE_CURRENT_SOURCE_DIR}/scripts/*/about.txt" - ) - file(GLOB_RECURSE SPHINX_SCRIPT_DEPS - "${CMAKE_CURRENT_SOURCE_DIR}/scripts/*.lua" - "${CMAKE_CURRENT_SOURCE_DIR}/scripts/*.rb" - ) - set(SPHINX_DEPS ${SPHINX_DEPS} ${SPHINX_SCRIPT_DEPS} - "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.rst" - "${CMAKE_CURRENT_SOURCE_DIR}/NEWS.rst" - "${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt" - ) - - set(SPHINX_OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/docs/html/.buildinfo") - set_source_files_properties(${SPHINX_OUTPUT} PROPERTIES GENERATED TRUE) - add_custom_command(OUTPUT ${SPHINX_OUTPUT} - COMMAND ${SPHINX_EXECUTABLE} - -a -E -q -b html - "${CMAKE_CURRENT_SOURCE_DIR}" - "${CMAKE_CURRENT_SOURCE_DIR}/docs/html" - -w "${CMAKE_CURRENT_SOURCE_DIR}/docs/_sphinx-warnings.txt" - -j 2 - DEPENDS ${SPHINX_DEPS} - COMMENT "Building HTML documentation with Sphinx" - ) - - add_custom_target(dfhack_docs ALL - DEPENDS ${SPHINX_OUTPUT} - ) - # Sphinx doesn't touch this file if it didn't make changes, - # which makes CMake think it didn't complete - add_custom_command(TARGET dfhack_docs POST_BUILD - COMMAND ${CMAKE_COMMAND} -E touch ${SPHINX_OUTPUT}) - - install(DIRECTORY ${dfhack_SOURCE_DIR}/docs/html/ - DESTINATION ${DFHACK_USERDOC_DESTINATION}/docs - ) - install(FILES "README.html" DESTINATION "${DFHACK_DATA_DESTINATION}") +if(INSTALL_SCRIPTS) + add_subdirectory(scripts) +endif() + +if(BUILD_DOCS) + find_package(Python3) + find_package(Sphinx) + + if(NOT SPHINX_FOUND) + message(SEND_ERROR "Sphinx not found but BUILD_DOCS enabled") + endif() + + file(GLOB SPHINX_GLOB_DEPS + LIST_DIRECTORIES false + "${CMAKE_CURRENT_SOURCE_DIR}/docs/images/*.png" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/styles/*" + "${CMAKE_CURRENT_SOURCE_DIR}/data/init/*init" + ) + file(GLOB_RECURSE SPHINX_GLOB_RECURSE_DEPS + "${CMAKE_CURRENT_SOURCE_DIR}/*.rst" + "${CMAKE_CURRENT_SOURCE_DIR}/changelog.txt" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/*py" + ) + list(FILTER SPHINX_GLOB_RECURSE_DEPS + EXCLUDE REGEX "docs/changelogs" + ) + list(FILTER SPHINX_GLOB_RECURSE_DEPS + EXCLUDE REGEX "docs/html" + ) + list(FILTER SPHINX_GLOB_RECURSE_DEPS + EXCLUDE REGEX "docs/tags" + ) + list(FILTER SPHINX_GLOB_RECURSE_DEPS + EXCLUDE REGEX "docs/text" + ) + list(FILTER SPHINX_GLOB_RECURSE_DEPS + EXCLUDE REGEX "docs/tools" + ) + set(SPHINX_DEPS ${SPHINX_GLOB_DEPS} ${SPHINX_GLOB_RECURSE_DEPS} ${SPHINX_SCRIPT_DEPS} + "${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt" + "${CMAKE_CURRENT_SOURCE_DIR}/conf.py" + ) + + if(BUILD_DOCS_NO_HTML) + set(SPHINX_OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/docs/text/index.txt") + set(SPHINX_BUILD_TARGETS text) + else() + set(SPHINX_OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/docs/html/.buildinfo") + set(SPHINX_BUILD_TARGETS html text) + endif() + + set_property( + DIRECTORY PROPERTY ADDITIONAL_CLEAN_FILES TRUE + "${CMAKE_CURRENT_SOURCE_DIR}/docs/changelogs" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/html" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/pdf" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/pseudoxml" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/tags" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/text" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/tools" + "${CMAKE_CURRENT_SOURCE_DIR}/docs/xml" + "${CMAKE_BINARY_DIR}/docs/html" + "${CMAKE_BINARY_DIR}/docs/pdf" + "${CMAKE_BINARY_DIR}/docs/pseudoxml" + "${CMAKE_BINARY_DIR}/docs/text" + "${CMAKE_BINARY_DIR}/docs/xml" + ) + + add_custom_command(OUTPUT ${SPHINX_OUTPUT} + COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/docs/build.py" + ${SPHINX_BUILD_TARGETS} --sphinx="${SPHINX_EXECUTABLE}" --quiet -- -W + DEPENDS ${SPHINX_DEPS} + COMMENT "Building documentation with Sphinx" + ) + + add_custom_target(dfhack_docs ALL + DEPENDS ${SPHINX_OUTPUT} + ) + # Sphinx doesn't touch this file if it didn't make changes, + # which makes CMake think it didn't complete + add_custom_command(TARGET dfhack_docs POST_BUILD + COMMAND ${CMAKE_COMMAND} -E touch ${SPHINX_OUTPUT}) + + if(NOT BUILD_DOCS_NO_HTML) + install(DIRECTORY ${dfhack_SOURCE_DIR}/docs/html/ + DESTINATION ${DFHACK_USERDOC_DESTINATION}/docs + FILES_MATCHING PATTERN "*" + PATTERN html/_sources EXCLUDE) + endif() + install(DIRECTORY ${dfhack_SOURCE_DIR}/docs/text/ + DESTINATION ${DFHACK_USERDOC_DESTINATION}/docs) + install(FILES docs/changelogs/news.rst docs/changelogs/news-dev.rst DESTINATION ${DFHACK_USERDOC_DESTINATION}) + install(FILES "README.html" DESTINATION "${DFHACK_DATA_DESTINATION}") +endif() + +option(BUILD_TESTS "Include tests (currently just installs Lua tests into the scripts folder)" OFF) +if(BUILD_TESTS) + if(EXISTS "${dfhack_SOURCE_DIR}/test/scripts") + message(SEND_ERROR "test/scripts must not exist in the dfhack repo since it would conflict with the tests installed from the scripts repo.") + endif() + install(DIRECTORY ${dfhack_SOURCE_DIR}/test + DESTINATION ${DFHACK_DATA_DESTINATION}/scripts) + install(FILES ci/test.lua DESTINATION ${DFHACK_DATA_DESTINATION}/scripts) endif() # Packaging with CPack! -SET(DFHACK_PACKAGE_SUFFIX "") -IF(UNIX) +set(DFHACK_PACKAGE_SUFFIX "") +if(UNIX) execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION) string(STRIP ${GCC_VERSION} GCC_VERSION) - SET(DFHACK_PACKAGE_SUFFIX "-gcc-${GCC_VERSION}") - if(APPLE) - SET(CPACK_GENERATOR "ZIP;TBZ2") - else() - SET(CPACK_GENERATOR "TBZ2") - endif() -ELSEIF(WIN32) - SET(CPACK_GENERATOR "ZIP") -ENDIF() + set(DFHACK_PACKAGE_SUFFIX "-gcc-${GCC_VERSION}") + set(CPACK_GENERATOR "TBZ2") +elseif(WIN32) + set(CPACK_GENERATOR "ZIP") +endif() set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0) -IF(APPLE) +if(APPLE) set(DFHACK_PACKAGE_PLATFORM_NAME OSX) -ELSE() +else() set(DFHACK_PACKAGE_PLATFORM_NAME ${CMAKE_SYSTEM_NAME}) -ENDIF() -set(CPACK_PACKAGE_FILE_NAME "dfhack-${DFHACK_VERSION}-${DFHACK_PACKAGE_PLATFORM_NAME}${DFHACK_PACKAGE_SUFFIX}") -INCLUDE(CPack) +endif() +# set on command line +if(DFHACK_BUILD_ID STREQUAL "") + set(DFHACK_BUILD_ID_PACKAGE "") +else() + set(DFHACK_BUILD_ID_PACKAGE "${DFHACK_BUILD_ID}-") +endif() +set(CPACK_PACKAGE_FILE_NAME "dfhack-${DFHACK_VERSION}-${DFHACK_BUILD_ID_PACKAGE}${DFHACK_PACKAGE_PLATFORM_NAME}-${DFHACK_BUILD_ARCH}bit${DFHACK_PACKAGE_SUFFIX}") +include(CPack) + +option(DFHACK_INCLUDE_CORE "Download and include Dwarf Fortress core files in DFHack. Useful for local testing, but should not be used in releases." OFF) +if(DFHACK_INCLUDE_CORE) + string(REPLACE "." "_" DF_CORE_FILENAME "${DF_VERSION}") + string(REGEX REPLACE "^0_" "df_" DF_CORE_FILENAME "${DF_CORE_FILENAME}") + if(UNIX) + if(APPLE) + string(APPEND DF_CORE_FILENAME "_osx") + else() + string(APPEND DF_CORE_FILENAME "_linux") + endif() + if(DFHACK_BUILD_32) + string(APPEND DF_CORE_FILENAME "32") + endif() + string(APPEND DF_CORE_FILENAME ".tar.bz2") + else() + string(APPEND DF_CORE_FILENAME "_win") + if(DFHACK_BUILD_32) + string(APPEND DF_CORE_FILENAME "32") + endif() + string(APPEND DF_CORE_FILENAME ".zip") + endif() + set(DF_CORE_URL "http://bay12games.com/dwarves/${DF_CORE_FILENAME}") + if(NOT EXISTS "${CMAKE_BINARY_DIR}/${DF_CORE_FILENAME}") + file(DOWNLOAD "${DF_CORE_URL}" "${CMAKE_BINARY_DIR}/${DF_CORE_FILENAME}" SHOW_PROGRESS) + endif() + file(REMOVE_RECURSE "${CMAKE_BINARY_DIR}/df-core") + file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/df-core") + if(UNIX) + execute_process(COMMAND ${CMAKE_COMMAND} -E tar xjf "../${DF_CORE_FILENAME}" --strip-components=1 + WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/df-core") + else() + execute_process(COMMAND ${CMAKE_COMMAND} -E tar xf "../${DF_CORE_FILENAME}" --format=zip + WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/df-core") + file(REMOVE "${CMAKE_BINARY_DIR}/df-core/SDL.dll") + endif() + install(DIRECTORY "${CMAKE_BINARY_DIR}/df-core/" + DESTINATION .) +endif() + +# Store old build arch +set(DFHACK_BUILD_ARCH_PREV "${DFHACK_BUILD_ARCH}" CACHE STRING "Previous build architecture" FORCE) + +option(BUILD_SIZECHECK "Build the sizecheck library, for research" OFF) +if(BUILD_LIBRARY AND BUILD_SIZECHECK) + add_subdirectory(depends/sizecheck) + add_dependencies(dfhack sizecheck) +endif() -#INCLUDE(FindSphinx.cmake) +add_subdirectory(package) diff --git a/CMakeSettings.json b/CMakeSettings.json new file mode 100644 index 0000000000..d1511716f7 --- /dev/null +++ b/CMakeSettings.json @@ -0,0 +1,284 @@ +{ + "configurations": [ + { + "name": "MSVC 64 Debug", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "inheritEnvironments": [ "msvc_x64_x64" ], + "variables": [ + { + "name": "DFHACK_BUILD_ARCH", + "value": "64" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + }, + { + "name": "REMOVE_SYMBOLS_FROM_DF_STUBS", + "value": "0" + }, + { + "name": "DFHACK_INCLUDE_CORE", + "value": "1" + } + ] + }, + { + "name": "MSVC 64 Release", + "generator": "Ninja", + "configurationType": "Release", + "inheritEnvironments": [ "msvc_x64_x64" ], + "variables": [ + { + "name": "DFHACK_BUILD_ARCH", + "value": "64" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + } + ] + }, + { + "name": "GCC 32 Debug", + "remoteMachineName": "${defaultRemoteMachineName}", + "remoteCMakeListsRoot": "/tmp/dfhack-${workspaceHash}/src", + "remoteBuildRoot": "/tmp/dfhack-${workspaceHash}/debug-32", + "rsyncCommandArgs": "--exclude=build --include=.git", + "remoteCopySources": true, + "cmakeExecutable": "$(which cmake)/..", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "intelliSenseMode": "linux-gcc-x86", + "variables": [ + { + "name": "DFHACK_BUILD_ARCH", + "value": "32" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + }, + { + "name": "REMOVE_SYMBOLS_FROM_DF_STUBS", + "value": "0" + }, + { + "name": "DFHACK_INCLUDE_CORE", + "value": "1" + } + ] + }, + { + "name": "GCC 32 Release", + "remoteMachineName": "${defaultRemoteMachineName}", + "remoteCMakeListsRoot": "/tmp/dfhack-${workspaceHash}/src", + "remoteBuildRoot": "/tmp/dfhack-${workspaceHash}/release-32", + "rsyncCommandArgs": "--exclude=build --include=.git", + "remoteCopySources": true, + "cmakeExecutable": "$(which cmake)/..", + "generator": "Ninja", + "configurationType": "Release", + "intelliSenseMode": "linux-gcc-x86", + "variables": [ + { + "name": "DFHACK_BUILD_ARCH", + "value": "32" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + } + ] + }, + { + "name": "GCC 64 Debug", + "remoteMachineName": "${defaultRemoteMachineName}", + "remoteCMakeListsRoot": "/tmp/dfhack-${workspaceHash}/src", + "remoteBuildRoot": "/tmp/dfhack-${workspaceHash}/debug-64", + "rsyncCommandArgs": "--exclude=build --include=.git", + "remoteCopySources": true, + "cmakeExecutable": "$(which cmake)/..", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "intelliSenseMode": "linux-gcc-x64", + "variables": [ + { + "name": "DFHACK_BUILD_ARCH", + "value": "64" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + }, + { + "name": "REMOVE_SYMBOLS_FROM_DF_STUBS", + "value": "0" + }, + { + "name": "DFHACK_INCLUDE_CORE", + "value": "1" + } + ] + }, + { + "name": "GCC 64 Release", + "remoteMachineName": "${defaultRemoteMachineName}", + "remoteCMakeListsRoot": "/tmp/dfhack-${workspaceHash}/src", + "remoteBuildRoot": "/tmp/dfhack-${workspaceHash}/release-64", + "rsyncCommandArgs": "--exclude=build --include=.git", + "remoteCopySources": true, + "cmakeExecutable": "$(which cmake)/..", + "generator": "Ninja", + "configurationType": "Release", + "intelliSenseMode": "linux-gcc-x64", + "variables": [ + { + "name": "DFHACK_BUILD_ARCH", + "value": "64" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + } + ] + }, + { + "name": "GCC 4.8 32 Debug", + "remoteMachineName": "${defaultRemoteMachineName}", + "remoteCMakeListsRoot": "/tmp/dfhack-${workspaceHash}/src", + "remoteBuildRoot": "/tmp/dfhack-${workspaceHash}/debug-32-48", + "rsyncCommandArgs": "--exclude=build --include=.git", + "remoteCopySources": true, + "cmakeExecutable": "$(which cmake)/..", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "intelliSenseMode": "linux-gcc-x86", + "variables": [ + { + "name": "CMAKE_C_COMPILER", + "value": "gcc-4.8" + }, + { + "name": "CMAKE_CXX_COMPILER", + "value": "g++-4.8" + }, + { + "name": "DFHACK_BUILD_ARCH", + "value": "32" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + }, + { + "name": "REMOVE_SYMBOLS_FROM_DF_STUBS", + "value": "0" + }, + { + "name": "DFHACK_INCLUDE_CORE", + "value": "1" + } + ] + }, + { + "name": "GCC 4.8 32 Release", + "remoteMachineName": "${defaultRemoteMachineName}", + "remoteCMakeListsRoot": "/tmp/dfhack-${workspaceHash}/src", + "remoteBuildRoot": "/tmp/dfhack-${workspaceHash}/release-32-48", + "rsyncCommandArgs": "--exclude=build --include=.git", + "remoteCopySources": true, + "cmakeExecutable": "$(which cmake)/..", + "generator": "Ninja", + "configurationType": "Release", + "intelliSenseMode": "linux-gcc-x86", + "variables": [ + { + "name": "CMAKE_C_COMPILER", + "value": "gcc-4.8" + }, + { + "name": "CMAKE_CXX_COMPILER", + "value": "g++-4.8" + }, + { + "name": "DFHACK_BUILD_ARCH", + "value": "32" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + } + ] + }, + { + "name": "GCC 4.8 64 Debug", + "remoteMachineName": "${defaultRemoteMachineName}", + "remoteCMakeListsRoot": "/tmp/dfhack-${workspaceHash}/src", + "remoteBuildRoot": "/tmp/dfhack-${workspaceHash}/debug-64-48", + "rsyncCommandArgs": "--exclude=build --include=.git", + "remoteCopySources": true, + "cmakeExecutable": "$(which cmake)/..", + "generator": "Ninja", + "configurationType": "RelWithDebInfo", + "intelliSenseMode": "linux-gcc-x64", + "variables": [ + { + "name": "CMAKE_C_COMPILER", + "value": "gcc-4.8" + }, + { + "name": "CMAKE_CXX_COMPILER", + "value": "g++-4.8" + }, + { + "name": "DFHACK_BUILD_ARCH", + "value": "64" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + }, + { + "name": "REMOVE_SYMBOLS_FROM_DF_STUBS", + "value": "0" + }, + { + "name": "DFHACK_INCLUDE_CORE", + "value": "1" + } + ] + }, + { + "name": "GCC 4.8 64 Release", + "remoteMachineName": "${defaultRemoteMachineName}", + "remoteCMakeListsRoot": "/tmp/dfhack-${workspaceHash}/src", + "remoteBuildRoot": "/tmp/dfhack-${workspaceHash}/release-64-48", + "rsyncCommandArgs": "--exclude=build --include=.git", + "remoteCopySources": true, + "cmakeExecutable": "$(which cmake)/..", + "generator": "Ninja", + "configurationType": "Release", + "intelliSenseMode": "linux-gcc-x64", + "variables": [ + { + "name": "CMAKE_C_COMPILER", + "value": "gcc-4.8" + }, + { + "name": "CMAKE_CXX_COMPILER", + "value": "g++-4.8" + }, + { + "name": "DFHACK_BUILD_ARCH", + "value": "64" + }, + { + "name": "BUILD_STONESENSE", + "value": "1" + } + ] + } + ] +} diff --git a/Contributing.rst b/Contributing.rst deleted file mode 100644 index 2c1e7bb451..0000000000 --- a/Contributing.rst +++ /dev/null @@ -1,228 +0,0 @@ -########################### -How to contribute to DFHack -########################### - -.. contents:: - - -.. _contributing-code: - -Contributing Code -================= -Several things should be kept in mind when contributing code to DFHack. - -Code Format ------------ -* Four space indents for C++. Never use tabs for indentation in any language. -* LF (Unix style) line terminators -* Avoid trailing whitespace -* UTF-8 encoding -* For C++: - - * Opening and closing braces on their own lines or opening brace at the end of the previous line - * Braces placed at original indent level if on their own lines - * #includes should be sorted. C++ libraries first, then dfhack modules, then df structures, - then local includes. Within each category they should be sorted alphabetically. - -How to get new code into DFHack -------------------------------- -* Submit pull requests to the ``develop`` branch, not the ``master`` branch. - (The ``master`` branch always points at the most recent release) -* Use a new branch for each feature or bugfix so that your changes can be merged independently - (i.e. not the master or develop branch of your fork). -* If possible, compile on multiple platforms when changing anything that compiles -* It must pass CI - run ``python travis/all.py`` to check this. -* Update ``NEWS.rst`` and ``docs/Authors.rst`` when applicable. -* Create a GitHub pull request once finished -* Submit ideas and bug reports as :issue:`issues on GitHub <>`. - Posts in the forum thread can easily get missed or forgotten. -* Work on :issue:`reported problems ` - will take priority over ideas or suggestions. - -.. _contributing-memory-research: - -Memory research ---------------- -If you want to do memory research, you'll need some tools and some knowledge. -In general, you'll need a good memory viewer and optionally something -to look at machine code without getting crazy :) -Using publicly known information and analyzing the game's data is preferred. - -Good windows tools include: - -* Cheat Engine -* IDA Pro 5.0 (freely available for non-commercial use) - -Good linux tools: - -* angavrilov's df-structures gui (visit us on IRC for details). -* edb (Evan's Debugger) -* IDA Pro 5.0 running under Wine -* Some of the tools residing in the ``legacy`` dfhack branch. - -Using the library as a developer -================================ -Currently, the most direct way to use the library is to write a script or plugin that can be loaded by it. -All the plugins can be found in the 'plugins' folder. There's no in-depth documentation -on how to write one yet, but it should be easy enough to copy one and just follow the pattern. -``plugins/skeleton/skeleton.cpp`` is provided for this purpose. - -Other than through plugins, it is possible to use DFHack via remote access interface, -or by writing scripts in Lua or Ruby. There are plenty of examples in the scripts folder. -The `lua-api` is quite well documented. - -The most important parts of DFHack are the Core, Console, Modules and Plugins. - -* Core acts as the centerpiece of DFHack - it acts as a filter between DF and - SDL and synchronizes the various plugins with DF. -* Console is a thread-safe console that can be used to invoke commands exported by Plugins. -* Modules actually describe the way to access information in DF's memory. You - can get them from the Core. Most modules are split into two parts: high-level - and low-level. High-level is mostly method calls, low-level publicly visible - pointers to DF's data structures. -* Plugins are the tools that use all the other stuff to make things happen. - A plugin can have a list of commands that it exports and an onupdate function - that will be called each DF game tick. - -Rudimentary API documentation can be built using doxygen (see build options -in ``CMakeCache.txt`` or with ``ccmake`` or ``cmake-gui``). The full DFHack -documentation is built with Sphinx_, which runs automatically at compile time. - -.. _Sphinx: http://www.sphinx-doc.org - -DFHack consists of variously licensed code, but invariably weak copyleft. -The main license is zlib/libpng, some bits are MIT licensed, and some are -BSD licensed. See the `license` for more information. - -Feel free to add your own extensions and plugins. Contributing back to -the DFHack repository is welcome and the right thing to do :) - -DF data structure definitions ------------------------------ -DFHack uses information about the game data structures, represented via xml files -in the ``library/xml/`` submodule. - -See https://github.com/DFHack/df-structures, and the documentation linked in the index. - -Data structure layouts are described in files following the ``df.*.xml`` name pattern. -This information is transformed by a perl script into C++ headers describing the -structures, and associated metadata for the Lua wrapper. These headers and data -are then compiled into the DFHack libraries, thus necessitating a compatibility -break every time layouts change; in return it significantly boosts the efficiency -and capabilities of DFHack code. - -Global object addresses are stored in :file:`symbols.xml`, which is copied to the dfhack -release package and loaded as data at runtime. - -Remote access interface ------------------------ -DFHack supports remote access by exchanging Google protobuf messages via a TCP -socket. Both the core and plugins can define remotely accessible methods. The -``dfhack-run`` command uses this interface to invoke ordinary console commands. - -Currently the supported set of requests is limited, because the developers don't -know what exactly is most useful. `remotefortressreader` provides a fairly -comprehensive interface for visualisers such as :forums:`Armok Vision <146473>`. - - -Documentation Standards -======================= -DFHack documentation is built with Sphinx_, and configured automatically -through CMake. If you want to build the docs *only*, use this command:: - - sphinx-build . docs/html - -Whether you're adding new code or just fixing old documentation (and there's plenty), -there are a few important standards for completeness and consistent style. Treat -this section as a guide rather than iron law, match the surrounding text, and you'll -be fine. - -Each command should have a short (~54 character) help string, which is shown -by the `ls` command. For scripts, this is a comment on the first line -(the comment marker and whitespace is stripped). For plugins it's the second -argument to ``PluginCommand``. Please make this brief but descriptive! - -Everything should be documented! If it's not clear *where* a particular -thing should be documented, ask on IRC or in the DFHack thread on Bay12 - -as well as getting help, you'll be providing valuable feedback that -makes it easier for future readers! - -Scripts can use a custom autodoc function, based on the Sphinx ``include`` -directive - anything between the tokens is copied into the appropriate scripts -documentation page. For Ruby, we follow the built-in docstring convention -(``=begin`` and ``=end``). For Lua, the tokens are ``[====[`` and ``]====]`` -- ordinary multi-line strings. It is highly encouraged to reuse this string -as the in-console documentation by (eg.) printing it when a ``-help`` argument -is given. - -The docs **must** have a heading which exactly matches the command, underlined -with ``=====`` to the same length. For example, a lua file would have:: - - local helpstr = [====[ - - add-thought - =========== - Adds a thought or emotion to the selected unit. Can be used by other scripts, - or the gui invoked by running ``add-thought gui`` with a unit selected. - - ]====] - - -Where the heading for a section is also the name of a command, the spelling -and case should exactly match the command to enter in the DFHack command line. - -Try to keep lines within 80-100 characters, so it's readable in plain text -in the terminal - Sphinx (our documentation system) will make sure -paragraphs flow. - -If there aren't many options or examples to show, they can go in a paragraph of -text. Use double-backticks to put commands in monospaced font, like this:: - - You can use ``cleanowned scattered x`` to dump tattered or abandoned items. - -If the command takes more than three arguments, format the list as a table -called Usage. The table *only* lists arguments, not full commands. -Input values are specified in angle brackets. Example:: - - Usage: - - :arg1: A simple argument. - :arg2 : Does something based on the input value. - :Very long argument: - Is very specific. - -To demonstrate usage - useful mainly when the syntax is complicated, list the -full command with arguments in monospaced font, then indent the next line and -describe the effect:: - - ``resume all`` - Resumes all suspended constructions. - -If it would be helpful to mention another DFHack command, don't just type the -name - add a hyperlink! Specify the link target in backticks, and it will be -replaced with the corresponding title and linked: eg ```autolabor``` -=> `autolabor`. Link targets should be equivalent to the command -described (without file extension), and placed above the heading of that -section like this:: - - .. _autolabor: - - autolabor - ========= - -Add link targets if you need them, but otherwise plain headings are preferred. -Scripts have link targets created automatically. - -Other ways to help -================== -DFHack is a software project, but there's a lot more to it than programming. -If you're not comfortable programming, you can help by: - -* reporting bugs and incomplete documentation -* improving the documentation -* finding third-party scripts to add -* writing tutorials for newbies - -All those things are crucial, and often under-represented. So if that's -your thing, go get started! - diff --git a/LICENSE.rst b/LICENSE.rst index e6a643e3d9..1ab6a682ee 100644 --- a/LICENSE.rst +++ b/LICENSE.rst @@ -4,16 +4,19 @@ Licenses ######## -DFHack is distributed under the Zlib license, with some MIT- -and BSD-licensed components. These licenses protect your right -to use DFhack for any purpose, distribute copies, and so on. +DFHack is distributed under the Zlib license, with some MIT- and BSD-licensed +components. These licenses protect your right to use DFHack for any purpose, +distribute copies, and so on. -The core, plugins, scripts, and other DFHack code all use the -ZLib license unless noted otherwise. By contributing to DFHack, -authors release the contributed work under this license. +The core, plugins, scripts, and other DFHack code all use the ZLib license +unless noted otherwise. By contributing to DFHack, authors release the +contributed work under this license. -DFHack also draws on several external packages. -Their licenses are summarised here and reproduced below. +Some graphic assets are derived from vanilla DF assets and used with permission +from Bay12. + +DFHack also draws on several external packages. Their licenses are summarised +here and reproduced below. =============== ============= ================================================= Component License Copyright @@ -23,13 +26,19 @@ clsocket_ BSD 3-clause \(c\) 2007-2009, CarrierLabs, LLC. dirent_ MIT \(c\) 2006, Toni Ronkko JSON.lua_ CC-BY-SA_ \(c\) 2010-2014, Jeffrey Friedl jsoncpp_ MIT \(c\) 2007-2010, Baptiste Lepilleur +libexpat_ MIT \(c\) 1998-2000 Thai Open Source Software Center Ltd and Clark Cooper \(c\) 2001-2019 Expat maintainers +libzip_ BSD 3-clause \(c\) 1999-2020 Dieter Baron and Thomas Klausner linenoise_ BSD 2-clause \(c\) 2010, Salvatore Sanfilippo & Pieter Noordhuis lua_ MIT \(c\) 1994-2008, Lua.org, PUC-Rio. +luacov_ MIT \(c\) 2007 - 2018 Hisham Muhammad luafilesystem_ MIT \(c\) 2003-2014, Kepler Project +lua-profiler_ MIT \(c\) 2002,2003,2004 Pepperfish protobuf_ BSD 3-clause \(c\) 2008, Google Inc. -tinythread_ Zlib \(c\) 2010, Marcus Geelnard tinyxml_ Zlib \(c\) 2000-2006, Lee Thomason UTF-8-decoder_ MIT \(c\) 2008-2010, Bjoern Hoehrmann +xlsxio_ MIT \(c\) 2016-2020, Brecht Sanders +alt-getopt_ MIT \(c\) 2009 Aleksey Cheusov +googletest_ BSD 3-Clause \(c\) 2008, Google Inc. =============== ============= ================================================= .. _DFHack: https://github.com/DFHack/dfhack @@ -37,13 +46,19 @@ UTF-8-decoder_ MIT \(c\) 2008-2010, Bjoern Hoehrmann .. _dirent: https://github.com/tronkko/dirent .. _JSON.lua: http://regex.info/blog/lua/json .. _jsoncpp: https://github.com/open-source-parsers/jsoncpp +.. _libexpat: https://github.com/libexpat/libexpat +.. _libzip: https://github.com/nih-at/libzip .. _linenoise: http://github.com/antirez/linenoise .. _lua: http://www.lua.org +.. _luacov: https://github.com/keplerproject/luacov .. _luafilesystem: https://github.com/keplerproject/luafilesystem +.. _lua-profiler: http://lua-users.org/wiki/PepperfishProfiler .. _protobuf: https://github.com/google/protobuf -.. _tinythread: http://tinythreadpp.bitsnbites.eu/ .. _tinyxml: http://www.sourceforge.net/projects/tinyxml .. _UTF-8-decoder: http://bjoern.hoehrmann.de/utf-8/decoder/dfa +.. _xlsxio: https://github.com/brechtsanders/xlsxio +.. _alt-getopt: https://github.com/LuaDist/alt-getopt +.. _googletest: https://github.com/google/googletest .. _CC-BY-SA: http://creativecommons.org/licenses/by/3.0/deed.en_US diff --git a/NEWS.rst b/NEWS.rst deleted file mode 100644 index dcc87b04af..0000000000 --- a/NEWS.rst +++ /dev/null @@ -1,537 +0,0 @@ -.. comment - This is the changelog file for DFHack. If you add or change anything, note - it here under the heading "DFHack Future", in the appropriate section. - Items within each section are listed in alphabetical order to minimise merge - conflicts. Try to match the style and level of detail of the other entries. - - Sections for each release are added as required, and consist solely of the - following in order as subheadings:: - - Internals - Lua - New [Internal Commands | Plugins | Scripts | Features] - Fixes - Misc Improvements - Removed - - When referring to a script, plugin, or command, use backticks (```) to - create a link to the relevant documentation - and check that the docs are - still up to date! - - When adding a new release, change "DFHack future" to the appropriate title - before releasing, and then add a new "DFHack future" section after releasing. - -.. _changelog: - -######### -Changelog -######### - -.. contents:: - :depth: 2 - -DFHack 0.43.03-r1 -================= - -Lua ---- -- Label widgets can now easily register handlers for mouse clicks - -New Features ------------- -- `add-thought`: allow syndrome name as ``-thought`` argument -- `gui/gm-editor` - - - Added ability to insert default types into containers. For primitive types leave the type entry empty, and for references use ``*``. - - Added ``shift-esc`` binding to fully exit from editor - - Added ``gui/gm-editor toggle`` command to toggle editor visibility (saving position) - -- `modtools/create-unit`: - - - Added an option to attach units to an existing wild animal population - - Added an option to attach units to a map feature - -Fixes ------ -- `autofarm`: Can now handle crops that grow for more than a season -- `combine-plants`: Fixed recursion into sub-containers -- `createitem`: Now moves multiple created items to cursor correctly -- `exportlegends`: Improved handling of unknown enum items (fixes many errors) -- `gui/create-item`: Fixed quality when creating multiple items -- `gui/mod-manager`: Fixed error when mods folder doesn't exist -- `modtools/item-trigger`: Fixed handling of items with subtypes -- `stockflow`: - - - Can order metal mechanisms - - Fixed material category of thread-spinning jobs - -Misc Improvements ------------------ -- The built-in ``ls`` command now wraps the descriptions of commands -- `catsplosion`: now a lua script instead of a plugin -- `fix/diplomats`: replaces ``fixdiplomats`` -- `fix/merchants`: replaces ``fixmerchants`` -- Unified script documentation and in-terminal help options - -Removed -------- -- `tweak` manager-quantity: no longer needed - -DFHack 0.42.06-r1 -================= - -Internals ---------- -- Commands to run on startup can be specified on the command line with ``+`` - - Example:: - - ./dfhack +devel/print-args example - "Dwarf Fortress.exe" +devel/print-args example - -- Prevented plugins with active viewscreens from being unloaded and causing a crash -- Additional script search paths can be specified in dfhack-config/script-paths.txt - -Lua ---- -- `building-hacks` now supports ``auto_gears`` flags. It automatically finds and animates gears in building definition -- Changed how `eventful` triggers reaction complete. Now it has ``onReactionComplete`` and ``onReactionCompleting``. Second one can be canceled - -New Plugins ------------ -- `autogems`: Creates a new Workshop Order setting, automatically cutting rough gems - -New Scripts ------------ -- `devel/save-version`: Displays DF version information about the current save -- `modtools/extra-gamelog`: replaces ``log-region``, ``soundsense-season``, and ``soundsense`` - -New Features ------------- -- `buildingplan`: Support for floodgates, grates, and bars -- `colonies`: new ``place`` subcommand and supports any vermin (default honey bees) -- `confirm`: Added a confirmation for retiring locations -- `exportlegends`: Exports more information (poetic/musical/dance forms, written/artifact content, landmasses, extra histfig information, and more) -- `search-plugin`: Support for new screens: - - - location occupation assignment - - civilization animal training knowledge - - animal trainer assignment - -- `tweak`: - - - ``tweak block-labors``: Prevents labors that can't be used from being toggled - - ``tweak hide-priority``: Adds an option to hide designation priority indicators - - ``tweak title-start-rename``: Adds a safe rename option to the title screen "Start Playing" menu - -- `zone`: - - - Added ``unassign`` subcommand - - Added ``only`` option to ``assign`` subcommand - -Fixes ------ -- Fixed a crash bug caused by the historical figures DFHack uses to store persistent data. -- More plugins should recognize non-dwarf citizens -- Fixed a possible crash from cloning jobs -- moveToBuilding() now sets flags for items that aren't a structural part of the building properly -- `autotrade`, `stocks`: Made trading work when multiple caravans are present but only some can trade -- `confirm` note-delete: No longer interferes with name entry -- `exportlegends`: Handles entities without specific races, and a few other fixes for things new to v0.42 -- `fastdwarf`: Fixed a bug involving teleporting mothers but not the babies they're holding. -- `gaydar`: Fixed text display on OS X/Linux and failure with soul-less creatures -- `manipulator`: - - - allowed editing of non-dwarf citizens - - stopped ghosts and visitors from being editable - - fixed applying last custom profession - -- `modtools/create-unit`: Stopped making units without civs historical figures -- `modtools/force`: - - - Removed siege option - - Prevented a crash resulting from a bad civilization option - -- `showmood`: Fixed name display on OS X/Linux -- `view-item-info`: Fixed density units - -Misc Improvements ------------------ -- `autochop`: Can now edit log minimum/maximum directly and remove limit entirely -- `autolabor`, `autohauler`, `manipulator`: Added support for new jobs/labors/skills -- `colonies`: now implemented by a script -- `createitem`: Can now create items anywhere without specifying a unit, as long as a unit exists on the map -- `devel/export-dt-ini`: Updated for 0.42.06 -- `devel/find-offsets`: Automated several more scans -- `gui/gm-editor`: Now supports finding some items with a numeric ID (with ``i``) -- `lua`: Now supports some built-in variables like `gui/gm-editor`, e.g. ``unit``, ``screen`` -- `remotefortressreader`: Can now trigger keyboard events -- `stockflow`: Now offers better control over individual craft jobs -- `weather`: now implemented by a script -- `zone`: colored output - -Removed -------- -- DFusion: legacy script system, obsolete or replaced by better alternatives - - -DFHack 0.40.24-r5 -================= - -New Features ------------- -- `confirm`: - - - Added a ``uniform-delete`` option for military uniform deletion - - Added a basic in-game configuration UI - -Fixes ------ -- Fixed a rare crash that could result from running `keybinding` in onLoadWorld.init -- Script help that doesn't start with a space is now recognized correctly -- `confirm`: Fixed issues with haul-delete, route-delete, and squad-disband confirmations intercepting keys too aggressively -- `emigration` should work now -- `fix-unit-occupancy`: Significantly optimized - up to 2,000 times faster in large fortresses -- `gui/create-item`: Allow exiting quantity prompt -- `gui/family-affairs`: Fixed an issue where lack of relationships wasn't recognized and other issues -- `modtools/create-unit`: Fixed a possible issue in reclaim fortress mode -- `search-plugin`: Fixed a crash on the military screen -- `tweak` max-wheelbarrow: Fixed a minor display issue with large numbers -- `workflow`: Fixed a crash related to job postings (and added a fix for existing, broken jobs) - -Misc Improvements ------------------ -- Unrecognized command feedback now includes more information about plugins -- `fix/dry-buckets`: replaces the ``drybuckets`` plugin -- `feature`: now implemented by a script - -DFHack 0.40.24-r4 -================= - -Internals ---------- -- A method for caching screen output is now available to Lua (and C++) -- Developer plugins can be ignored on startup by setting the ``DFHACK_NO_DEV_PLUGINS`` environment variable -- The console on Linux and OS X now recognizes keyboard input between prompts -- JSON libraries available (C++ and Lua) -- More DFHack build information used in plugin version checks and available to plugins and lua scripts -- Fixed a rare overflow issue that could cause crashes on Linux and OS X -- Stopped DF window from receiving input when unfocused on OS X -- Fixed issues with keybindings involving :kbd:`Ctrl`:kbd:`A` and :kbd:`Ctrl`:kbd:`Z`, - as well as :kbd:`Alt`:kbd:`E`/:kbd:`U`/:kbd:`N` on OS X -- Multiple contexts can now be specified when adding keybindings -- Keybindings can now use :kbd:`F10`-:kbd:`F12` and :kbd:`0`-:kbd:`9` -- Plugin system is no longer restricted to plugins that exist on startup -- :file:`dfhack.init` file locations significantly generalized - -Lua ---- -- Scripts can be enabled with the built-in `enable`/`disable ` commands -- A new function, ``reqscript()``, is available as a safer alternative to ``script_environment()`` -- Lua viewscreens can choose not to intercept the OPTIONS keybinding - -New internal commands ---------------------- -- `kill-lua`: Interrupt running Lua scripts -- `type`: Show where a command is implemented - -New plugins ------------ -- `confirm`: Adds confirmation dialogs for several potentially dangerous actions -- `fix-unit-occupancy`: Fixes issues with unit occupancy, such as faulty "unit blocking tile" messages (:bug:`3499`) -- `title-version` (formerly ``vshook``): Display DFHack version on title screen - -New scripts ------------ -- `armoks-blessing`: Adjust all attributes, personality, age and skills of all dwarves in play -- `brainwash`: brainwash a dwarf (modifying their personality) -- `burial`: sets all unowned coffins to allow burial ("-pets" to allow pets too) -- `deteriorateclothes`: make worn clothes on the ground wear far faster to boost FPS -- `deterioratecorpses`: make body parts wear away far faster to boost FPS -- `deterioratefood`: make food vanish after a few months if not used -- `elevate-mental`: elevate all the mental attributes of a unit -- `elevate-physical`: elevate all the physical attributes of a unit -- `emigration`: stressed dwarves may leave your fortress if they see a chance -- `fix-ster`: changes fertility/sterility of animals or dwarves -- `gui/family-affairs`: investigate and alter romantic relationships -- `make-legendary`: modify skill(s) of a single unit -- `modtools/create-unit`: create new units from nothing -- `modtools/equip-item`: a script to equip items on units -- `points`: set number of points available at embark screen -- `pref-adjust`: Adjust all preferences of all dwarves in play -- `rejuvenate`: make any "old" dwarf 20 years old -- `starvingdead`: make undead weaken after one month on the map, and crumble after six -- `view-item-info`: adds information and customisable descriptions to item viewscreens -- `warn-starving`: check for starving, thirsty, or very drowsy units and pause with warning if any are found - -New tweaks ----------- -- embark-profile-name: Allows the use of lowercase letters when saving embark profiles -- kitchen-keys: Fixes DF kitchen meal keybindings -- kitchen-prefs-color: Changes color of enabled items to green in kitchen preferences -- kitchen-prefs-empty: Fixes a layout issue with empty kitchen tabs - -Fixes ------ -- Plugins with vmethod hooks can now be reloaded on OS X -- Lua's ``os.system()`` now works on OS X -- Fixed default arguments in Lua gametype detection functions -- Circular lua dependencies (reqscript/script_environment) fixed -- Prevented crash in ``Items::createItem()`` -- `buildingplan`: Now supports hatch covers -- `gui/create-item`: fixed assigning quality to items, made :kbd:`Esc` work properly -- `gui/gm-editor`: handles lua tables properly -- `help`: now recognizes built-in commands, like ``help`` -- `manipulator`: fixed crash when selecting custom professions when none are found -- `remotefortressreader`: fixed crash when attempting to send map info when no map was loaded -- `search-plugin`: fixed crash in unit list after cancelling a job; fixed crash when disabling stockpile category after searching in a subcategory -- `stockpiles`: now checks/sanitizes filenames when saving -- `stocks`: fixed a crash when right-clicking -- `steam-engine`: fixed a crash on arena load; number keys (e.g. 2/8) take priority over cursor keys when applicable -- tweak fps-min fixed -- tweak farm-plot-select: Stopped controls from appearing when plots weren't fully built -- `workflow`: Fixed some issues with stuck jobs. Existing stuck jobs must be cancelled and re-added -- `zone`: Fixed a crash when using ``zone set`` (and a few other potential crashes) - -Misc Improvements ------------------ -- DFHack documentation: - - - massively reorganised, into files of more readable size - - added many missing entries - - indexes, internal links, offline search all documents - - includes documentation of linked projects (df-structures, third-party scripts) - - better HTML generation with Sphinx - - documentation for scripts now located in source files - -- `autolabor`: - - - Stopped modification of labors that shouldn't be modified for brokers/diplomats - - Prioritize skilled dwarves more efficiently - - Prevent dwarves from running away with tools from previous jobs - -- `automaterial`: Fixed several issues with constructions being allowed/disallowed incorrectly when using box-select -- `dwarfmonitor`: - - - widgets' positions, formats, etc. are now customizable - - weather display now separated from the date display - - New mouse cursor widget - -- `gui/dfstatus`: Can enable/disable individual categories and customize metal bar list -- `full-heal`: ``-r`` option removes corpses -- `gui/gm-editor` - - - Pointers can now be displaced - - Added some useful aliases: "item" for the selected item, "screen" for the current screen, etc. - - Now avoids errors with unrecognized types - -- `gui/hack-wish`: renamed to `gui/create-item` -- `keybinding list ` accepts a context -- `lever`: - - - Lists lever names - - ``lever pull`` can be used to pull the currently-selected lever - -- ``memview``: Fixed display issue -- `modtools/create-item`: arguments are named more clearly, and you can specify the creator to be the unit with id ``df.global.unit_next_id-1`` (useful in conjunction with `modtools/create-unit`) -- ``nyan``: Can now be stopped with dfhack-run -- `plug`: lists all plugins; shows state and number of commands in plugins -- `prospect`: works from within command-prompt -- `quicksave`: Restricted to fortress mode -- `remotefortressreader`: Exposes more information -- `search-plugin`: - - - Supports noble suggestion screen (e.g. suggesting a baron) - - Supports fortress mode loo[k] menu - - Recognizes ? and ; keys - -- `stocks`: can now match beginning and end of item names -- `teleport`: Fixed cursor recognition -- `tidlers`, `twaterlvl`: now implemented by scripts instead of a plugin -- `tweak`: - - - debug output now logged to stderr.log instead of console - makes DFHack start faster - - farm-plot-select: Fixed issues with selecting undiscovered crops - -- `workflow`: Improved handling of plant reactions - -Removed -------- -- `embark-tools` nano: 1x1 embarks are now possible in vanilla 0.40.24 - -DFHack 0.40.24-r3 -================= - -Internals ---------- -- Ruby library now included on OS X - Ruby scripts should work on OS X 10.10 -- libstdc++ should work with older versions of OS X -- Added support for `onMapLoad.init / onMapUnload.init ` scripts -- game type detection functions are now available in the World module -- The ``DFHACK_LOG_MEM_RANGES`` environment variable can be used to log information to ``stderr.log`` on OS X -- Fixed adventure mode menu names -- Fixed command usage information for some commands - -Lua ---- -- Lua scripts will only be reloaded if necessary -- Added a ``df2console()`` wrapper, useful for printing DF (CP437-encoded) text to the console in a portable way -- Added a ``strerror()`` wrapper - -New Internal Commands ---------------------- -- `hide`, `show`: hide and show the console on Windows -- `sc-script`: Allows additional scripts to be run when certain events occur (similar to `onLoad.init` scripts) - -New Plugins ------------ -- `autohauler`: A hauling-only version of autolabor - -New Scripts ------------ -- `modtools/reaction-product-trigger`: triggers callbacks when products are produced (contrast with when reactions complete) - -New Tweaks ----------- -- `fps-min `: Fixes the in-game minimum FPS setting -- `shift-8-scroll `: Gives Shift+8 (or ``*``) priority when scrolling menus, instead of scrolling the map -- `tradereq-pet-gender `: Displays pet genders on the trade request screen - -Fixes ------ -- Fixed game type detection in `3dveins`, `gui/create-item`, `reveal`, `seedwatch` -- ``PRELOAD_LIB``: More extensible on Linux -- `add-spatter`, `eventful`: Fixed crash on world load -- `add-thought`: Now has a proper subthought arg. -- `building-hacks`: Made buildings produce/consume correct amount of power -- `fix-armory`: compiles and is available again (albeit with issues) -- `gui/gm-editor`: Added search option (accessible with "s") -- `hack-wish `: Made items stack properly. -- `modtools/skill-change`: Made level granularity work properly. -- `show-unit-syndromes`: should work -- `stockflow`: - - - Fixed error message in Arena mode - - no longer checks the DF version - - fixed ballistic arrow head orders - - convinces the bookkeeper to update records more often - -- `zone`: Stopped crash when scrolling cage owner list - -Misc Improvements ------------------ -- `autolabor`: A negative pool size can be specified to use the most unskilled dwarves -- `building-hacks`: - - - Added a way to allow building to work even if it consumes more power than is available. - - Added setPower/getPower functions. - -- `catsplosion`: Can now trigger pregnancies in (most) other creatures -- `exportlegends`: ``info`` and ``all`` options export ``legends_plus.xml`` with more data for legends utilities -- `manipulator`: - - - Added ability to edit nicknames/profession names - - added "Job" as a View Type, in addition to "Profession" and "Squad" - - added custom profession templates with masking - -- `remotefortressreader`: Exposes more information - - -DFHack 0.40.24-r2 -================= - -Internals ---------- -- Lua scripts can set environment variables of each other with ``dfhack.run_script_with_env`` -- Lua scripts can now call each others internal nonlocal functions with ``dfhack.script_environment(scriptName).functionName(arg1,arg2)`` -- `eventful`: Lua reactions no longer require LUA_HOOK as a prefix; you can register a callback for the completion of any reaction with a name -- Filesystem module now provides file access/modification times and can list directories (normally and recursively) -- Units Module: New functions:: - - isWar - isHunter - isAvailableForAdoption - isOwnCiv - isOwnRace - getRaceName - getRaceNamePlural - getRaceBabyName - getRaceChildName - isBaby - isChild - isAdult - isEggLayer - isGrazer - isMilkable - isTrainableWar - isTrainableHunting - isTamable - isMale - isFemale - isMerchant - isForest - isMarkedForSlaughter - -- Buildings Module: New Functions:: - - isActivityZone - isPenPasture - isPitPond - isActive - findPenPitAt - -Fixes ------ -- ``dfhack.run_script`` should correctly find save-specific scripts now. -- `add-thought`: updated to properly affect stress. -- `hfs-pit`: should work now -- `autobutcher`: takes gelding into account -- :file:`init.lua` existence checks should be more reliable (notably when using non-English locales) - -Misc Improvements ------------------ -Multiline commands are now possible inside dfhack.init scripts. See :file:`dfhack.init-example` for example usage. - - -DFHack 0.40.24-r1 -================= - -Internals ---------- -CMake shouldn't cache DFHACK_RELEASE anymore. People may need to manually update/delete their CMake cache files to get rid of it. - - -DFHack 0.40.24-r0 -================= - -Internals ---------- -- `EventManager`: fixed crash error with EQUIPMENT_CHANGE event. -- key modifier state exposed to Lua (ie :kbd:`Ctrl`, :kbd:`Alt`, :kbd:`Shift`) - -Fixes ------ -``dfhack.sh`` can now be run from other directories on OS X - -New Plugins ------------ -- `blueprint`: export part of your fortress to quickfort .csv files - -New Scripts ------------ -- `hotkey-notes`: print key, name, and jump position of hotkeys - -Removed -------- -- needs_porting/* - -Misc Improvements ------------------ -Added support for searching more lists - - -Older Changelogs -================ -Are kept in a seperate file: `HISTORY` - -.. that's ``docs/history.rst``, if you're reading the raw text. diff --git a/README.html b/README.html index b8e15a0d11..4d1b0fd13c 100644 --- a/README.html +++ b/README.html @@ -13,4 +13,4 @@ Follow this link to the documentation. - \ No newline at end of file + diff --git a/README.md b/README.md index 50769e0c50..3a2db02fc5 100644 --- a/README.md +++ b/README.md @@ -1,24 +1,15 @@ -#DFHack Readme +# DFHack Readme -[![Build Status](https://travis-ci.org/DFHack/dfhack.svg?branch=develop)] -(https://travis-ci.org/DFHack/dfhack) -[![Documentation Status](https://readthedocs.org/projects/dfhack/badge)] -(https://dfhack.readthedocs.org) -[![License](https://img.shields.io/badge/license-ZLib-blue.svg)] -(https://en.wikipedia.org/wiki/Zlib_License) -[![Github Issues](http://githubbadges.herokuapp.com/DFHack/dfhack/issues)] -(https://github.com/DFHack/dfhack/issues) -[![Open Pulls](http://githubbadges.herokuapp.com/DFHack/dfhack/pulls)] -(https://github.com/DFHack/dfhack/pulls) +[![Build Status](https://github.com/DFHack/dfhack/workflows/Build/badge.svg?event=push)](https://github.com/DFHack/dfhack/actions?query=workflow%3ABuild) +[![Documentation Status](https://readthedocs.org/projects/dfhack/badge)](https://dfhack.readthedocs.org) +[![License](https://img.shields.io/badge/license-ZLib-blue.svg)](https://en.wikipedia.org/wiki/Zlib_License) +[![Discord](https://img.shields.io/discord/793331351645323264)](https://dfhack.org/discord) DFHack is a Dwarf Fortress memory access library, distributed with scripts and plugins implementing a wide variety of useful functions and tools. -The full documentation [is available online here](https://dfhack.readthedocs.org), -from the README.html page in the DFHack distribution, or as raw text in the `./docs` folder. -If you're an end-user, modder, or interested in contributing to DFHack - -go read those docs. +The full documentation [is available online here](https://dfhack.readthedocs.org). +If you have DFHack installed, it is also accessible as raw text in the `hack/docs` folder. +If you're an end-user, modder, or interested in contributing to DFHack -- go read those docs. -If that's unclear or you need more help, try [the Bay12 forums thread] -(http://www.bay12forums.com/smf/index.php?topic=139553) or the #dfhack IRC -channel on freenode. +If the docs are unclear or you need more help, please check out our [support page](https://docs.dfhack.org/en/latest/docs/Support.html) for ways to contact the DFHack developers. diff --git a/build/.gitignore b/build/.gitignore index 10192a42e3..0675a165cf 100644 --- a/build/.gitignore +++ b/build/.gitignore @@ -1,4 +1,11 @@ VC2010 +VC2015 +VC2015_32 +VC2022 DF_PATH.txt _CPack_Packages *.tar.* +.cmake +win64-cross +dest +DF diff --git a/build/build-debug.bat b/build/build-debug.bat deleted file mode 100644 index a9492de135..0000000000 --- a/build/build-debug.bat +++ /dev/null @@ -1,4 +0,0 @@ -call "%VS100COMNTOOLS%vsvars32.bat" -cd VC2010 -msbuild /m /p:Platform=Win32 /p:Configuration=RelWithDebInfo ALL_BUILD.vcxproj -cd .. \ No newline at end of file diff --git a/build/build-osx.sh b/build/build-osx.sh old mode 100644 new mode 100755 index 8e34101597..e6be0f3085 --- a/build/build-osx.sh +++ b/build/build-osx.sh @@ -7,88 +7,88 @@ LUA_PATCH=1 ME=$PWD/`basename $0` usage() { - echo "Usage: $0 [options] {DF_OSX_PATH}" - echo -e "\told\t- use on pre-Snow Leopard OSX installations" - echo -e "\tbrew\t- if GCC 4.5 was installed with homebrew" - echo -e "\tport\t- if GCC 4.5 was insalled with macports" - echo -e "\tclean\t- delete ../build-osx before compiling" - echo "Example:" - echo -e "\t$0 old brew ../../../personal/df_osx" - echo -e "\t$0 port clean /Users/dfplayer/df_osx" - exit $1 + echo "Usage: $0 [options] {DF_OSX_PATH}" + echo -e "\told\t- use on pre-Snow Leopard OSX installations" + echo -e "\tbrew\t- if GCC 4.5 was installed with homebrew" + echo -e "\tport\t- if GCC 4.5 was insalled with macports" + echo -e "\tclean\t- delete ../build-osx before compiling" + echo "Example:" + echo -e "\t$0 old brew ../../../personal/df_osx" + echo -e "\t$0 port clean /Users/dfplayer/df_osx" + exit $1 } options() { - case $1 in - brew) - echo "Using homebrew gcc." - export CC=/usr/local/bin/gcc-4.5 - export CXX=/usr/local/bin/g++-4.5 - targetted=1 - ;; - port) - echo "Using macports gcc." - export CC=/opt/local/bin/gcc-mp-4.5 - export CXX=/opt/local/bin/g++-mp-4.5 - targetted=1 - ;; - old) - LUA_PATCH=0 - ;; - clean) - echo "Deleting ../build-osx" - rm -rf ../build-osx - ;; - *) - ;; - esac + case $1 in + brew) + echo "Using homebrew gcc." + export CC=/usr/local/bin/gcc-4.5 + export CXX=/usr/local/bin/g++-4.5 + targetted=1 + ;; + port) + echo "Using macports gcc." + export CC=/opt/local/bin/gcc-mp-4.5 + export CXX=/opt/local/bin/g++-mp-4.5 + targetted=1 + ;; + old) + LUA_PATCH=0 + ;; + clean) + echo "Deleting ../build-osx" + rm -rf ../build-osx + ;; + *) + ;; + esac } # sanity checks if [[ $# -lt 1 ]] then - echo "Not enough arguments." - usage 0 + echo "Not enough arguments." + usage 0 fi if [[ $# -gt 4 ]] then - echo "Too many arguments." - usage 1 + echo "Too many arguments." + usage 1 fi # run through the arguments for last do - options $last + options $last done # last keeps the last argument if [[ $targetted -eq 0 ]] then - echo "You did not specify whether you intalled GCC 4.5 from brew or ports." - echo "If you continue, your default compiler will be used." - read -p "Are you sure you want to continue? [y/N] " -n 1 -r - echo # (optional) move to a new line - if [[ ! $REPLY =~ ^[Yy]$ ]] - then - exit 0 - fi + echo "You did not specify whether you intalled GCC 4.5 from brew or ports." + echo "If you continue, your default compiler will be used." + read -p "Are you sure you want to continue? [y/N] " -n 1 -r + echo # (optional) move to a new line + if [[ ! $REPLY =~ ^[Yy]$ ]] + then + exit 0 + fi fi # check for build folder and start working there if [[ ! -d ../build-osx ]] then - mkdir ../build-osx + mkdir ../build-osx fi cd ../build-osx # patch if necessary if [[ $LUA_PATCH -ne 0 ]] then - cd .. - echo "$PWD" - sed -e '1,/'"PATCH""CODE"'/d' "$ME" | patch -p0 - cd - + cd .. + echo "$PWD" + sed -e '1,/'"PATCH""CODE"'/d' "$ME" | patch -p0 + cd - fi echo "Generate" @@ -101,17 +101,17 @@ make install # unpatch if /libarary/luaTypes.cpp was patched if [[ $LUA_PATCH -ne 0 ]] then - cd .. - echo -n "un" - sed -e '1,/'"PATCH""CODE"'/d' "$ME" | patch -p0 -R - cd - + cd .. + echo -n "un" + sed -e '1,/'"PATCH""CODE"'/d' "$ME" | patch -p0 -R + cd - fi exit 0 # PATCHCODE - everything below this line is fed into patch ---- library/LuaTypes.cpp 2014-08-20 00:13:17.000000000 -0700 -+++ library/LuaTypes.cpp 2014-08-31 23:31:00.000000000 -0700 +--- library/LuaTypes.cpp 2014-08-20 00:13:17.000000000 -0700 ++++ library/LuaTypes.cpp 2014-08-31 23:31:00.000000000 -0700 @@ -464,7 +464,7 @@ { case struct_field_info::STATIC_STRING: diff --git a/build/build-release.bat b/build/build-release.bat deleted file mode 100644 index e1ad315e53..0000000000 --- a/build/build-release.bat +++ /dev/null @@ -1,5 +0,0 @@ -call "%VS100COMNTOOLS%vsvars32.bat" -cd VC2010 -msbuild /m /p:Platform=Win32 /p:Configuration=Release ALL_BUILD.vcxproj -cd .. -pause \ No newline at end of file diff --git a/build/build-win64-from-linux.sh b/build/build-win64-from-linux.sh new file mode 100755 index 0000000000..529893412f --- /dev/null +++ b/build/build-win64-from-linux.sh @@ -0,0 +1,60 @@ +#!/bin/bash + +set -e +# Number of jobs == core count +jobs=$(grep -c ^processor /proc/cpuinfo) + +# Calculate absolute paths for docker to do mounts +srcdir=$(realpath "$(dirname "$(readlink -f "$0")")"/..) + +cd "$srcdir"/build + +builder_uid=$(id -u) + +mkdir -p win64-cross +mkdir -p win64-cross/output +mkdir -p win64-cross/pdb +mkdir -p win64-cross/ccache + +# Check for sudo; we want to use the real user +if [[ $(id -u) -eq 0 ]]; then + if [[ -z "$SUDO_UID" || "$SUDO_UID" -eq 0 ]]; then + echo "Please don't run this script directly as root, use sudo instead:" + echo + echo " sudo $0" + # This is because we can't change the buildmaster UID in the container to 0 -- + # that's already taken by root. + exit 1 + fi + + # If this was run using sudo, let's make sure the directories are owned by the + # real user (and set the BUILDER_UID to it) + builder_uid=$SUDO_UID + chown -R $builder_uid win64-cross +fi + +# Pulls the MSVC build env container from the GitHub registry +# +# NOTE: win64-cross is mounted in /src/build due to the hardcoded `cmake ..` in +# the Dockerfile +if ! docker run --rm -i -v "$srcdir":/src -v "$srcdir/build/win64-cross/":/src/build \ + -e BUILDER_UID=$builder_uid \ + -e CCACHE_DIR=/src/build/ccache \ + -e steam_username \ + -e steam_password \ + --name dfhack-win \ + ghcr.io/dfhack/build-env:master \ + bash -c "cd /src/build && dfhack-configure windows 64 Release -DCMAKE_INSTALL_PREFIX=/src/build/output -DBUILD_DOCS=1 $CMAKE_EXTRA_ARGS && dfhack-make -j$jobs install && find . \! -path './pdb/*' -name '*.pdb' -type f -exec cp '{}' pdb/ \;" \ + ; then + echo + echo "Build failed" + exit 1 +else + echo + echo "Windows artifacts are at win64-cross/output. Copy or symlink them to" + echo "your steam DF directory to install dfhack (and optionally delete the" + echo "hack/ directory already present)" + echo + echo "Typically this can be done like this:" + echo " cp -r win64-cross/output/* ~/.local/share/Steam/steamapps/common/\"Dwarf Fortress\"" +fi diff --git a/build/generate-MSVC-all-breakfast.bat b/build/generate-MSVC-all-breakfast.bat deleted file mode 100644 index 1921fba6c8..0000000000 --- a/build/generate-MSVC-all-breakfast.bat +++ /dev/null @@ -1,9 +0,0 @@ -@echo off -IF EXIST DF_PATH.txt SET /P _DF_PATH= mtime: + folder = f + mtime = os.path.getmtime(makefile) + if not folder: + raise BuildError('No valid build folder found') + return folder + +def get_plugin_name(filename): + filename = filename.replace('/devel', '') + match = re.search(r'plugins/(.+?)[/\.]', filename) + if match: + return match.group(1) + +def run_command(cmd): + print('$ ' + ' '.join(cmd)) + sys.stdout.flush() + if subprocess.call(cmd) != 0: + raise BuildError('command execution failed: ' + ' '.join(cmd)) + +def main(args): + os.chdir(find_build_folder()) + print('Build folder:', os.getcwd()) + cmd = ['make', '-j3'] + + if args.plugin: + plugin = get_plugin_name(args.file) + if not plugin: + raise BuildError('Cannot determine current plugin name from %r' % args.file) + cmd += [plugin + '/fast'] + + run_command(cmd) + + if args.install: + run_command(['make', 'install/fast']) + +if __name__ == '__main__': + try: + main(parser.parse_args()) + except BuildError as e: + print('** Error: ' + str(e)) + sys.exit(1) diff --git a/build/win64/build-debug.bat b/build/win64/build-debug.bat new file mode 100644 index 0000000000..2db9df402c --- /dev/null +++ b/build/win64/build-debug.bat @@ -0,0 +1 @@ +cmake --build VC2022 -t ALL_BUILD -- /m /p:Platform=x64 /p:Configuration=RelWithDebInfo diff --git a/build/win64/build-release.bat b/build/win64/build-release.bat new file mode 100644 index 0000000000..f719d64bcf --- /dev/null +++ b/build/win64/build-release.bat @@ -0,0 +1 @@ +cmake --build VC2022 -t ALL_BUILD -- /m /p:Platform=x64 /p:Configuration=Release diff --git a/build/win64/generate-MSVC-all.bat b/build/win64/generate-MSVC-all.bat new file mode 100644 index 0000000000..29240da7fd --- /dev/null +++ b/build/win64/generate-MSVC-all.bat @@ -0,0 +1,4 @@ +IF EXIST DF_PATH.txt SET /P _DF_PATH= 0 Then + Set ObjF = fso.GetFolder(args.Item(0)) +else + Set objDlg = WScript.CreateObject("Shell.Application") + Set objF = objDlg.BrowseForFolder (&H0,"Select your DF folder", BIF_returnonlyfsdirs) + if IsValue(objF) Then + set ObjF = objF.self + end if +end if + If fso.FileExists("DF_PATH.txt") Then fso.DeleteFile "DF_PATH.txt", True End If -If IsValue(objF) Then +If IsValue(objF) Then If InStr(1, TypeName(objF), "Folder") > 0 Then Set spoFile = fso.CreateTextFile("DF_PATH.txt", True) - spoFile.WriteLine(objF.Self.Path) + spoFile.WriteLine(objF.Path) End If End If @@ -29,4 +39,4 @@ Function IsValue(obj) IsValue = True End If On Error GoTo 0 -End Function \ No newline at end of file +End Function diff --git a/travis/authors-rst.py b/ci/authors-rst.py old mode 100644 new mode 100755 similarity index 88% rename from travis/authors-rst.py rename to ci/authors-rst.py index 2d7274219b..6f37172761 --- a/travis/authors-rst.py +++ b/ci/authors-rst.py @@ -1,6 +1,7 @@ +#!/usr/bin/env python3 """ Overly-complicated script to check formatting/sorting in Authors.rst """ -import re, sys +import os, re, sys def main(): success = [True] @@ -9,8 +10,10 @@ def error(line, msg, **kwargs): for k in kwargs: info += ' %s %s:' % (k, kwargs[k]) print('line %i:%s %s' % (line, info, msg)) + if os.environ.get('GITHUB_ACTIONS'): + print('::error file=docs/about/Authors.rst,line=%i::%s %s' % (line, info.lstrip(), msg)) success[0] = False - with open('docs/Authors.rst', 'rb') as f: + with open('docs/about/Authors.rst', 'rb') as f: lines = list(map(lambda line: line.decode('utf8').replace('\n', ''), f.readlines())) if lines[1].startswith('='): @@ -32,6 +35,8 @@ def error(line, msg, **kwargs): error(line_number, 'bad table divider') if line != lines[first_div_index]: error(line_number, 'malformed table divider') + if line == lines[first_div_index + i - 1]: + error(line_number, 'duplicate of previous line') if len(div_indices) < 3: error(len(lines), 'missing table divider(s)') for i in div_indices[3:]: diff --git a/ci/build-lua.sh b/ci/build-lua.sh new file mode 100755 index 0000000000..e29d7ce879 --- /dev/null +++ b/ci/build-lua.sh @@ -0,0 +1,54 @@ +#!/bin/sh + +set -e + +LUA_ROOT="$HOME/lua53" +LUA_URL="http://www.lua.org/ftp/lua-5.3.3.tar.gz" +LUA_TAR=$(basename "$LUA_URL") +LUA_DIR="$LUA_ROOT/${LUA_TAR%.tar.*}" +LUA_SHA1="a0341bc3d1415b814cc738b2ec01ae56045d64ef" + +echo LUA_ROOT $LUA_ROOT +echo LUA_TAR $LUA_TAR +echo LUA_DIR $LUA_DIR + +sha1() { + python -c 'import hashlib, sys; print(hashlib.sha1(open(sys.argv[1],"rb").read()).hexdigest())' "$1" +} + +download() { + echo "Downloading $LUA_URL" + wget -O "$LUA_ROOT/$LUA_TAR" "$LUA_URL" + tar xvf "$LUA_ROOT/$LUA_TAR" +} + +build() { + cd "$LUA_DIR/src" + make generic +} + +main() { + mkdir -p "$LUA_ROOT" + cd "$LUA_ROOT" + mkdir -p bin + + if [ "$(sha1 "$LUA_ROOT/$LUA_TAR" 2>/dev/null)" != "$LUA_SHA1" ]; then + download + build + else + echo "Already downloaded" + + if [ -x "$LUA_DIR/src/luac" ]; then + echo "Already built" + else + build + fi + fi + + echo "Linking" + ln -sf "$LUA_DIR/src/lua" "$LUA_ROOT/bin/lua5.3" + ln -sf "$LUA_DIR/src/luac" "$LUA_ROOT/bin/luac5.3" + echo "Done" +} + +main diff --git a/ci/check-rpc.py b/ci/check-rpc.py new file mode 100755 index 0000000000..5527e1b58c --- /dev/null +++ b/ci/check-rpc.py @@ -0,0 +1,122 @@ +#!/usr/bin/env python3 +import glob +import itertools +import os +import sys + +actual = {'': {}} +SEP = ('=' * 80) + +with open(sys.argv[1]) as f: + plugin_name = '' + for line in f: + line = line.rstrip() + if line.startswith('// Plugin: '): + plugin_name = line.split(' ')[2] + if plugin_name not in actual: + actual[plugin_name] = {} + elif line.startswith('// RPC '): + parts = line.split(' ') + actual[plugin_name][parts[2]] = (parts[4], parts[6]) + +expected = {'': {}} + +for p in glob.iglob('library/proto/*.proto'): + with open(p) as f: + for line in f: + line = line.rstrip() + if line.startswith('// RPC '): + parts = line.split(' ') + expected[''][parts[2]] = (parts[4], parts[6]) + +for p in itertools.chain(glob.iglob('plugins/proto/*.proto'), glob.iglob('plugins/*/proto/*.proto')): + if 'plugins/' + os.path.join('proto', 'example.proto') in p: + continue + print('Checking ' + p) + + plugin_name = '' + with open(p) as f: + for line in f: + line = line.rstrip() + if line.startswith('// Plugin: '): + plugin_name = line.split(' ')[2] + if plugin_name not in expected: + expected[plugin_name] = {} + break + + if plugin_name == '': + continue + + with open(p) as f: + for line in f: + line = line.rstrip() + if line.startswith('// RPC '): + parts = line.split(' ') + expected[plugin_name][parts[2]] = (parts[4], parts[6]) + +error_count = 0 + +for plugin_name in actual: + methods = actual[plugin_name] + + if plugin_name not in expected: + print(SEP) + print('Missing documentation for plugin proto files: ' + plugin_name) + print('Add the following lines:') + print('// Plugin: ' + plugin_name) + error_count += 1 + for m in methods: + io = methods[m] + print('// RPC ' + m + ' : ' + io[0] + ' -> ' + io[1]) + error_count += 1 + else: + missing = [] + wrong = [] + for m in methods: + io = methods[m] + if m in expected[plugin_name]: + if expected[plugin_name][m] != io: + wrong.append('// RPC ' + m + ' : ' + io[0] + ' -> ' + io[1]) + else: + missing.append('// RPC ' + m + ' : ' + io[0] + ' -> ' + io[1]) + + if len(missing) > 0: + print(SEP) + print('Incomplete documentation for ' + ('core' if plugin_name == '' else 'plugin "' + plugin_name + '"') + ' proto files. Add the following lines:') + for m in missing: + print(m) + error_count += 1 + + if len(wrong) > 0: + print(SEP) + print('Incorrect documentation for ' + ('core' if plugin_name == '' else 'plugin "' + plugin_name + '"') + ' proto files. Replace the following comments:') + for m in wrong: + print(m) + error_count += 1 + +for plugin_name in expected: + methods = expected[plugin_name] + + if plugin_name not in actual: + print(SEP) + print('Incorrect documentation for plugin proto files: ' + plugin_name) + print('The following methods are documented, but the plugin does not provide any RPC methods:') + for m in methods: + io = methods[m] + print('// RPC ' + m + ' : ' + io[0] + ' -> ' + io[1]) + error_count += 1 + else: + missing = [] + for m in methods: + io = methods[m] + if m not in actual[plugin_name]: + missing.append('// RPC ' + m + ' : ' + io[0] + ' -> ' + io[1]) + + if len(missing) > 0: + print(SEP) + print('Incorrect documentation for ' + ('core' if plugin_name == '' else 'plugin "' + plugin_name + '"') + ' proto files. Remove the following lines:') + for m in missing: + print(m) + error_count += 1 + +sys.exit(min(100, error_count)) diff --git a/ci/download-df.sh b/ci/download-df.sh new file mode 100755 index 0000000000..a07f75f2a1 --- /dev/null +++ b/ci/download-df.sh @@ -0,0 +1,56 @@ +#!/bin/sh + +DF_FOLDER=$1 +OS_TARGET=$2 +DF_VERSION=$3 + +set -e + +minor=$(echo "$DF_VERSION" | cut -d. -f1) +patch=$(echo "$DF_VERSION" | cut -d. -f2) +if [ "$DF_VERSION" = "51.03" -o "$DF_VERSION" = "51.04" ]; then + patch=02 +fi +df_url="https://www.bay12games.com/dwarves/df_${minor}_${patch}" +if test "$OS_TARGET" = "windows"; then + WGET="C:/msys64/usr/bin/wget.exe" + df_url="${df_url}_win.zip" + df_archive_name="df.zip" + df_extract_cmd="unzip -d ${DF_FOLDER}" +elif test "$OS_TARGET" = "ubuntu"; then + WGET=wget + df_url="${df_url}_linux.tar.bz2" + df_archive_name="df.tar.bz2" + df_extract_cmd="tar -x -j -C ${DF_FOLDER} -f" +else + echo "Unhandled OS target: ${OS_TARGET}" + exit 1 +fi + +if ! $WGET -v "$df_url" -O "$df_archive_name"; then + echo "Failed to download DF from $df_url" + exit 1 +fi + +md5sum "$df_archive_name" + +save_url="https://dffd.bay12games.com/download.php?id=15434&f=dreamfort.7z" +save_archive_name="test_save.7z" +save_extract_cmd="7z x -o${DF_FOLDER}/save" + +if ! $WGET -v "$save_url" -O "$save_archive_name"; then + echo "Failed to download test save from $save_url" + exit 1 +fi + +md5sum "$save_archive_name" + +echo Extracting +mkdir -p ${DF_FOLDER} +$df_extract_cmd "$df_archive_name" +$save_extract_cmd "$save_archive_name" +mv ${DF_FOLDER}/save/* ${DF_FOLDER}/save/region1 + +echo Done + +ls -l diff --git a/ci/get-df-version.sh b/ci/get-df-version.sh new file mode 100755 index 0000000000..24386252d9 --- /dev/null +++ b/ci/get-df-version.sh @@ -0,0 +1,4 @@ +#!/bin/sh +cd "$(dirname "$0")" +cd .. +grep -i 'set(DF_VERSION' CMakeLists.txt | perl -ne 'print "$&\n" if /[\d\.]+/' diff --git a/ci/lint-check.txt b/ci/lint-check.txt new file mode 100644 index 0000000000..bdfa74365f --- /dev/null +++ b/ci/lint-check.txt @@ -0,0 +1,32 @@ +# Files that lint.py should check + +*.bash +*.bat +*.c +*.cc +*.cmake +*.cpp +*.css +*.gitignore +*.h +*.hh +*.hpp +*.in +*.inc +*.init +*.init-example +*.js +*.lua +*.manifest +*.md +*.mm +*.pl +*.proto +*.py +*.rb +*.rst +*.sh +*.txt +*.vbs +*.yaml +*.yml diff --git a/ci/lint-ignore.txt b/ci/lint-ignore.txt new file mode 100644 index 0000000000..6e9d32cf01 --- /dev/null +++ b/ci/lint-ignore.txt @@ -0,0 +1,24 @@ +# Files that lint.py should ignore + +.git/* + +# Old files exempt from checks for now +plugins/raw/*.txt +plugins/stonesense/*.txt + +# Generated files +*.pb.h +build*/* +docs/changelogs/* +docs/html/* +docs/pdf/* +docs/pseudoxml/* +docs/tags/* +docs/text/* +docs/tools/* +docs/xml/* +library/include/df/* + +# Dependencies that we don't control +depends/* +plugins/stonesense/allegro/* diff --git a/ci/lint.py b/ci/lint.py new file mode 100755 index 0000000000..f2c01cd9c5 --- /dev/null +++ b/ci/lint.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +import argparse +import fnmatch +import re +import os +import subprocess +import sys + +DFHACK_ROOT = os.path.normpath(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +def load_pattern_files(paths): + patterns = [] + for p in paths: + with open(p) as f: + for line in f.readlines(): + line = line.strip() + if line and not line.startswith('#'): + patterns.append(line) + return patterns + +def valid_file(rel_path, check_patterns, ignore_patterns): + return ( + any(fnmatch.fnmatch(rel_path, pattern) for pattern in check_patterns) + and not any(fnmatch.fnmatch(rel_path, pattern) for pattern in ignore_patterns) + ) + +success = True +def error(msg=None): + global success + success = False + if msg: + sys.stderr.write(msg + '\n') + +def format_lines(lines, total): + if len(lines) == total - 1: + return 'entire file' + if not len(lines): + # should never happen + return 'nowhere' + if len(lines) == 1: + return 'line %i' % lines[0] + s = 'lines ' + range_start = range_end = lines[0] + for i, line in enumerate(lines): + if line > range_end + 1: + if range_start == range_end: + s += ('%i, ' % range_end) + else: + s += ('%i-%i, ' % (range_start, range_end)) + range_start = range_end = line + if i == len(lines) - 1: + s += ('%i' % line) + else: + range_end = line + if i == len(lines) - 1: + s += ('%i-%i, ' % (range_start, range_end)) + return s.rstrip(' ').rstrip(',') + +class LinterError(Exception): + def __init__(self, message, lines, total_lines): + self.message = message + self.lines = lines + self.total_lines = total_lines + + def __str__(self): + return '%s: %s' % (self.message, format_lines(self.lines, self.total_lines)) + + def github_actions_workflow_command(self, filename): + first_line = self.lines[0] if self.lines else 1 + return '::error file=%s,line=%i::%s' % (filename, first_line, self) + +class Linter(object): + ignore = False + def check(self, lines): + failures = [] + for i, line in enumerate(lines): + if not self.check_line(line): + failures.append(i + 1) + if len(failures): + raise LinterError(self.msg, failures, len(lines)) + + def fix(self, lines): + for i in range(len(lines)): + lines[i] = self.fix_line(lines[i]) + + +class NewlineLinter(Linter): + msg = 'Contains DOS-style newlines' + # git supports newline conversion. Catch in CI, ignore on Windows. + ignore = os.linesep != '\n' and not os.environ.get('CI') + def check_line(self, line): + return '\r' not in line + def fix_line(self, line): + return line.replace('\r', '') + +class TrailingWhitespaceLinter(Linter): + msg = 'Contains trailing whitespace' + def check_line(self, line): + line = line.replace('\r', '').replace('\n', '') + return line == line.rstrip('\t ') + def fix_line(self, line): + return line.rstrip('\t ') + +class TabLinter(Linter): + msg = 'Contains tabs' + def check_line(self, line): + return '\t' not in line + def fix_line(self, line): + return line.replace('\t', ' ') + +linters = [cls() for cls in Linter.__subclasses__() if not cls.ignore] + +def walk_all(root_path): + for cur, dirnames, filenames in os.walk(root_path): + for filename in filenames: + full_path = os.path.join(cur, filename) + yield full_path + +def walk_git_files(root_path): + p = subprocess.Popen(['git', '-C', root_path, 'ls-files', root_path], stdout=subprocess.PIPE) + for line in p.stdout.readlines(): + path = line.decode('utf-8').strip() + full_path = os.path.join(root_path, path) + yield full_path + if p.wait() != 0: + raise RuntimeError('git exited with %r' % p.returncode) + +def main(args): + root_path = os.path.abspath(args.path) + if not os.path.exists(args.path): + print('Nonexistent path: %s' % root_path) + sys.exit(2) + + check_patterns = load_pattern_files(args.check_patterns) + ignore_patterns = load_pattern_files(args.ignore_patterns) + + walk_iter = walk_all + if args.git_only: + walk_iter = walk_git_files + + for full_path in walk_iter(root_path): + rel_path = full_path.replace(root_path, '').replace('\\', '/').lstrip('/') + if not valid_file(rel_path, check_patterns, ignore_patterns): + continue + if args.verbose: + print('Checking:', rel_path) + lines = [] + with open(full_path, 'rb') as f: + lines = f.read().split(b'\n') + for i, line in enumerate(lines): + try: + lines[i] = line.decode('utf-8') + except UnicodeDecodeError: + msg_params = (rel_path, i + 1, 'Invalid UTF-8 (other errors will be ignored)') + error('%s:%i: %s' % msg_params) + if args.github_actions: + print('::error file=%s,line=%i::%s' % msg_params) + lines[i] = '' + for linter in linters: + try: + linter.check(lines) + except LinterError as e: + error('%s: %s' % (rel_path, e)) + if args.github_actions: + print(e.github_actions_workflow_command(rel_path)) + if args.fix: + linter.fix(lines) + contents = '\n'.join(lines) + with open(full_path, 'wb') as f: + f.write(contents.encode('utf-8')) + + if success: + print('All linters completed successfully') + sys.exit(0) + else: + sys.exit(1) + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('path', nargs='?', default='.', + help='Path to scan (default: current directory)') + parser.add_argument('--fix', action='store_true', + help='Attempt to modify files in-place to fix identified issues') + parser.add_argument('--git-only', action='store_true', + help='Only check files tracked by git') + parser.add_argument('--github-actions', action='store_true', + help='Enable GitHub Actions workflow command output') + parser.add_argument('-v', '--verbose', action='store_true', + help='Log files as they are checked') + parser.add_argument('--check-patterns', action='append', + default=[os.path.join(DFHACK_ROOT, 'ci', 'lint-check.txt')], + help='File(s) containing filename patterns to check') + parser.add_argument('--ignore-patterns', action='append', + default=[os.path.join(DFHACK_ROOT, 'ci', 'lint-ignore.txt')], + help='File(s) containing filename patterns to ignore') + args = parser.parse_args() + main(args) diff --git a/ci/run-tests.py b/ci/run-tests.py new file mode 100755 index 0000000000..13eeb099c8 --- /dev/null +++ b/ci/run-tests.py @@ -0,0 +1,138 @@ +#!/usr/bin/env python3 +import argparse +import enum +import json +import os +import re +import shutil +import subprocess +import sys + +parser = argparse.ArgumentParser() +parser.add_argument('df_folder', help='DF base folder') +parser.add_argument('--headless', action='store_true', + help='Run without opening DF window (requires non-Windows)') +parser.add_argument('--keep-status', action='store_true', + help='Do not delete final status file') +parser.add_argument('--no-quit', action='store_true', + help='Do not quit DF when done') +parser.add_argument('--test-dir', '--test-folder', + help='Base test folder (default: df_folder/test)') +parser.add_argument('-t', '--test', dest='tests', nargs='+', + help='Test(s) to run (Lua patterns accepted)') +args = parser.parse_args() + +if (not sys.stdin.isatty() or not sys.stdout.isatty() or not sys.stderr.isatty()) and not args.headless: + print('WARN: no TTY detected, enabling headless mode') + args.headless = True + +if args.test_dir is not None: + args.test_dir = os.path.normpath(os.path.join(os.getcwd(), args.test_dir)) + if not os.path.isdir(args.test_dir): + print('ERROR: invalid test folder: %r' % args.test_dir) + +MAX_TRIES = 5 + +dfhack = 'Dwarf Fortress.exe' if sys.platform == 'win32' else './dfhack' +test_status_file = 'test_status.json' + +class TestStatus(enum.Enum): + PENDING = 'pending' + PASSED = 'passed' + FAILED = 'failed' + +def get_test_status(): + if os.path.isfile(test_status_file): + with open(test_status_file) as f: + return {k: TestStatus(v) for k, v in json.load(f).items()} + +def change_setting(content, setting, value): + return '[' + setting + ':' + value + ']\n' + re.sub( + r'\[' + setting + r':.+?\]', '(overridden)', content, flags=re.IGNORECASE) + +os.chdir(args.df_folder) +if os.path.exists(test_status_file): + os.remove(test_status_file) + +print('Backing up init.txt to init.txt.orig') +default_init_txt_path = 'data/init/init_default.txt' +prefs_path = 'prefs' +init_txt_path = 'prefs/init.txt' +if not os.path.exists(init_txt_path): + os.makedirs(prefs_path, exist_ok=True) + shutil.copyfile(default_init_txt_path, init_txt_path) + +shutil.copyfile(init_txt_path, init_txt_path + '.orig') +with open(init_txt_path) as f: + init_contents = f.read() +init_contents = change_setting(init_contents, 'SOUND', 'NO') +init_contents = change_setting(init_contents, 'WINDOWED', 'YES') +init_contents = change_setting(init_contents, 'WINDOWEDX', '1200') +init_contents = change_setting(init_contents, 'WINDOWEDY', '800') +#if args.headless: +# init_contents = change_setting(init_contents, 'PRINT_MODE', 'TEXT') + +init_path = 'dfhack-config/init' +if not os.path.isdir('hack/init'): + # we're on an old branch that still reads init files from the root dir + init_path = '.' +os.makedirs(init_path, exist_ok=True) +test_init_file = os.path.join(init_path, 'dfhackzzz_test.init') # Core sorts these alphabetically +with open(test_init_file, 'w') as f: + f.write(''' + devel/dump-rpc dfhack-rpc.txt + test --resume -- lua scr.breakdown_level=df.interface_breakdown_types.%s + ''' % ('NONE' if args.no_quit else 'QUIT')) + +test_config_file = 'test_config.json' +with open(test_config_file, 'w') as f: + json.dump({ + 'test_dir': args.test_dir, + 'tests': args.tests, + }, f) + +try: + with open(init_txt_path, 'w') as f: + f.write(init_contents) + + tries = 0 + while True: + status = get_test_status() + if status is not None: + if all(s != TestStatus.PENDING for s in status.values()): + print('Done!') + sys.exit(int(any(s != TestStatus.PASSED for s in status.values()))) + elif tries > 0: + print('ERROR: Could not read status file') + sys.exit(2) + + tries += 1 + print('Starting DF: #%i' % (tries)) + if tries > MAX_TRIES: + print('ERROR: Too many tries - aborting') + sys.exit(1) + + if args.headless: + os.environ['DFHACK_HEADLESS'] = '1' + os.environ['DFHACK_DISABLE_CONSOLE'] = '1' + + process = subprocess.Popen([dfhack], + stdin=subprocess.PIPE if args.headless else sys.stdin, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + out, err = process.communicate() + if err: + print('WARN: DF produced stderr: ' + repr(err[:5000])) + with open('df-raw-stderr.log', 'wb') as f: + f.write(err) + if process.returncode != 0: + print('ERROR: DF exited with ' + repr(process.returncode)) + print('DF stdout: ' + repr(out[:5000])) +finally: + print('\nRestoring original init.txt') + shutil.copyfile(init_txt_path + '.orig', init_txt_path) + if os.path.isfile(test_init_file): + os.remove(test_init_file) + if not args.keep_status and os.path.isfile(test_status_file): + os.remove(test_status_file) + print('Cleanup done') diff --git a/ci/script-docs.py b/ci/script-docs.py new file mode 100755 index 0000000000..0106a8f706 --- /dev/null +++ b/ci/script-docs.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python3 +import os +from os.path import basename, dirname, exists, join, splitext +import sys + +SCRIPT_PATH = sys.argv[1] if len(sys.argv) > 1 else 'scripts' +DOCS_PATH = join(SCRIPT_PATH, 'docs') +IS_GITHUB_ACTIONS = bool(os.environ.get('GITHUB_ACTIONS')) + +def get_cmd(path): + """Get the command from the name of a script.""" + dname, fname = basename(dirname(path)), splitext(basename(path))[0] + if dname in ('devel', 'fix', 'gui', 'modtools'): + return dname + '/' + fname + return fname + + +def print_error(message, filename, line=None): + if not isinstance(line, int): + line = 1 + print('Error: %s:%i: %s' % (filename, line, message)) + if IS_GITHUB_ACTIONS: + print('::error file=%s,line=%i::%s' % (filename, line, message)) + + +def check_ls(docfile, lines): + """Check length & existence of first sentence for "ls" builtin command.""" + # TODO + return 0 + + +def check_file(fname): + errors, doc_start_line = 0, None + docfile = join(DOCS_PATH, get_cmd(fname)+'.rst') + if not exists(docfile): + print_error('missing documentation file: {!r}'.format(docfile), fname) + return 1 + with open(docfile, errors='ignore') as f: + lines = f.readlines() + if not lines: + print_error('empty documentation file', docfile) + return 1 + for i, l in enumerate(lines): + l = l.strip() + if l and not doc_start_line and doc_start_line != 0: + doc_start_line = i + doc_end_line = i + lines[i] = l + + errors += check_ls(docfile, lines) + title, underline = lines[doc_start_line:doc_start_line+2] + expected_underline = '=' * len(title) + if underline != expected_underline: + print_error('title/underline mismatch: expected {!r}, got {!r}'.format( + expected_underline, underline), + docfile, doc_start_line+1) + errors += 1 + if title != get_cmd(fname): + print_error('expected script title {!r}, got {!r}'.format( + get_cmd(fname), title), + docfile, doc_start_line) + errors += 1 + return errors + + +def main(): + """Check that all DFHack scripts include documentation""" + err = 0 + exclude = {'.git', 'internal', 'test'} + for root, dirs, files in os.walk(SCRIPT_PATH, topdown=True): + dirs[:] = [d for d in dirs if d not in exclude] + for f in files: + if f.split('.')[-1] in {'rb', 'lua'}: + err += check_file(join(root, f)) + return err + + +if __name__ == '__main__': + sys.exit(min(100, main())) diff --git a/travis/script-syntax.py b/ci/script-syntax.py old mode 100644 new mode 100755 similarity index 52% rename from travis/script-syntax.py rename to ci/script-syntax.py index b3a264f048..593a25a241 --- a/travis/script-syntax.py +++ b/ci/script-syntax.py @@ -1,8 +1,26 @@ +#!/usr/bin/env python3 import argparse import os import subprocess import sys + +def print_stderr(stderr, args): + if not args.github_actions: + sys.stderr.write(stderr + '\n') + return + + for line in stderr.split('\n'): + print(line) + parts = list(map(str.strip, line.split(':'))) + # e.g. luac prints "luac:" in front of messages, so find the first part + # containing the actual filename + for i in range(len(parts) - 1): + if parts[i].endswith('.' + args.ext) and parts[i + 1].isdigit(): + print('::error file=%s,line=%s::%s' % (parts[i], parts[i + 1], ':'.join(parts[i + 2:]))) + break + + def main(args): root_path = os.path.abspath(args.path) cmd = args.cmd.split(' ') @@ -19,7 +37,13 @@ def main(args): continue full_path = os.path.join(cur, filename) try: - subprocess.check_output(cmd + [full_path]) + p = subprocess.Popen(cmd + [full_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + _, stderr = p.communicate() + stderr = stderr.decode('utf-8', errors='ignore') + if stderr: + print_stderr(stderr, args) + if p.returncode != 0: + err = True except subprocess.CalledProcessError: err = True except IOError: @@ -34,5 +58,7 @@ def main(args): parser.add_argument('--path', default='.', help='Root directory') parser.add_argument('--ext', help='Script extension', required=True) parser.add_argument('--cmd', help='Command', required=True) + parser.add_argument('--github-actions', action='store_true', + help='Enable GitHub Actions workflow command output') args = parser.parse_args() main(args) diff --git a/ci/test.lua b/ci/test.lua new file mode 100644 index 0000000000..a4846520ec --- /dev/null +++ b/ci/test.lua @@ -0,0 +1,752 @@ +-- DFHack developer test harness +--@ module = true + +local expect = require('test_util.expect') +local gui = require('gui') +local helpdb = require('helpdb') +local json = require('json') +local mock = require('test_util.mock') +local overlay = require('plugins.overlay') +local script = require('gui.script') +local utils = require('utils') + +local help_text = +[====[ + +test +==== + +Tags: dev + +Command: "test" + + Run DFHack regression tests. + +Discover DFHack functionality that has broken due to recent changes in DF or DFHack. + +Usage +----- + + test [] [] + +If a done_command is specified, it will be run after the tests complete. + +Options +------- + +-d, --test_dir specifies which directory to look in for tests. defaults to + the "hack/scripts/test" folder in your DF installation. +-m, --modes only run tests in the given comma separated list of modes. + see the next section for a list of valid modes. if not + specified, the tests are not filtered by modes. +-r, --resume skip tests that have already been run. remove the + test_status.json file to reset the record. +-s, --save_dir the save folder to load for "fortress" mode tests. this + save is only loaded if a fort is not already loaded when + a "fortress" mode test is run. if not specified, defaults to + 'region1'. +-t, --tests only run tests that match one of the comma separated list of + patterns. if not specified, no tests are filtered and all tessts + are run. + +Modes +----- + +none the test can be run on any screen +title the test must be run on the DF title screen. note that if the game + has a map loaded, "title" mode tests cannot be run +fortress the test must be run while a map is loaded. if the game is + currently on the title screen, the save specified by the save_dir + parameter will be loaded. + +Examples +-------- + +test runs all tests +test -r runs all tests that haven't been run before +test -m none runs tests that don't need the game to be in a + specific mode +test -t quickfort runs quickfort tests +test -d /path/to/dfhack-scripts/repo/test + runs tests in your dev scripts repo + +Default values for the options may be set in a file named test_config.json in +your DF folder. Options with comma-separated values should be written as json +arrays. For example: + + { + "test_dir": "/home/myk/src/dfhack-scripts/test", + "modes": [ "none" ], + "tests": [ "quickfort", "devel" ], + "done_command": "devel/luacov -c" + } + +]====] + +local CONFIG_FILE = 'test_config.json' +local STATUS_FILE = 'test_status.json' +local DF_STATE_FILE = 'test_df_state.json' +local TestStatus = { + PENDING = 'pending', + PASSED = 'passed', + FAILED = 'failed', +} + +local function delay(frames) + frames = frames or 1 + script.sleep(frames, 'frames') +end + +-- Will call the predicate_fn every frame until it returns true. If it fails to +-- return true before timeout_frames have elapsed, throws an error. If +-- timeout_frames is not specified, defaults to 100. +local function delay_until(predicate_fn, timeout_frames) + timeout_frames = tonumber(timeout_frames) or 100 + repeat + delay() + if predicate_fn() then return end + timeout_frames = timeout_frames - 1 + until timeout_frames < 0 + error('timed out while waiting for predicate to return true') +end + +local function clean_require(module) + -- wrapper around require() - forces a clean load of every module to ensure + -- that modules checking for dfhack.internal.IN_TEST at load time behave + -- properly + if package.loaded[module] then + reload(module) + end + return require(module) +end + +-- clean_run_script and clean_reqscript force a clean load of scripts directly +-- or indirectly included from the test file. we use our own scripts table +-- instead of the one in dfhack.internal so we don't affect the state scripts +-- that are used outside the test harness. +local test_scripts = {} +local test_envvars = {} + +-- clean_run_script is accessed via the dfhack table, not directly from the env. +-- therefore we use this function in wrap_test() below and not in test_envvars. +local function clean_run_script(name, ...) + return dfhack.run_script_with_env( + test_envvars, + name, + {scripts=test_scripts}, + ...) +end + +local function clean_reqscript(name) + local path = dfhack.findScript(name) + if test_scripts[path] then return test_scripts[path].env end + local _, env = dfhack.run_script_with_env( + test_envvars, + name, + { + scripts=test_scripts, + module=true, + module_strict=true + }) + return env +end +test_envvars.require = clean_require +test_envvars.reqscript = clean_reqscript + +local function is_title_screen() + return dfhack.gui.matchFocusString('title/Default') +end + +local function wait_for(ms, desc, predicate) + local start_ms = dfhack.getTickCount() + local prev_ms = start_ms + while not predicate() do + delay(10) + local now_ms = dfhack.getTickCount() + if now_ms - start_ms > ms then + qerror(('%s took too long (timed out at %s)'):format( + desc, dfhack.gui.getCurFocus(true)[1])) + end + if now_ms - prev_ms > 1000 then + print(('Waiting for %s...'):format(desc)) + prev_ms = now_ms + end + end +end + +-- This only handles pre-fortress-load screens. It will time out if the player +-- has already loaded a fortress or is in any screen that can't get to the title +-- screen by sending ESC keys. +local function ensure_title_screen() + if df.viewscreen_dwarfmodest:is_instance(dfhack.gui.getDFViewscreen(true)) then + qerror('Cannot reach title screen from loaded fort') + end + for i = 1, 100 do + local scr = dfhack.gui.getCurViewscreen() + if is_title_screen() then + print('Found title screen') + return + end + scr:feed_key(df.interface_key.LEAVESCREEN) + delay(10) + if i % 10 == 0 then print('Looking for title screen...') end + end + qerror(string.format('Could not find title screen (timed out at %s)', + dfhack.gui.getCurFocus(true)[1])) +end + +local function is_fortress() + return dfhack.gui.matchFocusString('dwarfmode/Default') +end + +-- error out if we're not running in a CI environment +-- the tests may corrupt saves, and we don't want to unexpectedly ruin a real player save +-- this heuristic is not perfect, but it should be able to detect most cases +local function ensure_ci_save(scr) + if #scr.savegame_header ~= 1 + or #scr.savegame_header_world ~= 1 + or not string.find(scr.savegame_header[0].fort_name, 'Dream') + then + qerror('Unexpected test save in slot 0; please manually load a fort for ' .. + 'running fortress mode tests. note that tests may alter or corrupt the ' .. + 'fort! Do not save after running tests.') + end +end + +local function click_top_title_button(scr) + local sw, sh = dfhack.screen.getWindowSize() + df.global.gps.mouse_x = sw // 2 + df.global.gps.precise_mouse_x = df.global.gps.mouse_x * df.global.gps.tile_pixel_x + if sh < 60 then + df.global.gps.mouse_y = 25 + else + df.global.gps.mouse_y = (sh // 2) + 3 + end + df.global.gps.precise_mouse_y = df.global.gps.mouse_y * df.global.gps.tile_pixel_y + gui.simulateInput(scr, '_MOUSE_L') +end + +local function load_first_save(scr) + if #scr.savegame_header == 0 then + qerror('no savegames available to load') + end + + click_top_title_button(scr) + wait_for(1000, 'world list', function() + return scr.mode == 2 + end) + click_top_title_button(scr) + wait_for(1000, 'savegame list', function() + return scr.mode == 3 + end) + click_top_title_button(scr) + wait_for(1000, 'loadgame progress bar', function() + return dfhack.gui.matchFocusString('loadgame') + end) +end + +-- Requires that a fortress game is already loaded or is ready to be loaded via +-- the "Continue active game" option in the title screen. Otherwise the function +-- will time out and/or exit with error. +local function ensure_fortress(config) + for screen_timeout = 1,10 do + if is_fortress() then + print('Fortress map is loaded') + -- pause the game (if it's not already paused) + dfhack.gui.resetDwarfmodeView(true) + return + end + local scr = dfhack.gui.getCurViewscreen() + if dfhack.gui.matchFocusString('title/Default', scr) then + print('Attempting to load the test fortress') + -- TODO: reinstate loading of a specified save dir; for now + -- just load the first possible save, which will at least let us + -- run fortress tests in CI + -- qerror()'s on falure + -- dfhack.run_script('load-save', config.save_dir) + ensure_ci_save(scr) + load_first_save(scr) + elseif not dfhack.gui.matchFocusString('loadgame', scr) then + -- if we're not actively loading a game, hope we're in + -- a screen where hitting ESC will get us to the game map + -- or the title screen + scr:feed_key(df.interface_key.LEAVESCREEN) + end + -- wait for current screen to change + local prev_focus_string = dfhack.gui.getCurFocus()[1] + wait_for(60000, 'screen change', function() + return dfhack.gui.getCurFocus()[1] ~= prev_focus_string + end) + end + qerror(string.format('Could not load fortress (timed out at %s)', + table.concat(dfhack.gui.getCurFocus(), ' '))) +end + +local MODES = { + none = {order=1, detect=function() return true end}, + title = {order=2, detect=is_title_screen, navigate=ensure_title_screen}, + fortress = {order=3, detect=is_fortress, navigate=ensure_fortress}, +} + +local function load_test_config(config_file) + local config = {} + print ("loading test config from " .. config_file) + if dfhack.filesystem.isfile(config_file) then + config = json.decode_file(config_file) + end + + if not config.test_dir then + config.test_dir = dfhack.getHackPath() .. '/scripts/test' + end + + if not config.save_dir then + config.save_dir = 'region1' + end + + return config +end + +local function TestTable() + local inner = utils.OrderedTable() + local meta = copyall(getmetatable(inner)) + + function meta:__newindex(k, v) + if inner[k] then + error('Attempt to overwrite existing test: ' .. k) + elseif type(v) ~= 'function' then + error('Attempt to define test as non-function: ' .. k .. ' = ' .. tostring(v)) + else + inner[k] = v + end + end + + local self = {} + setmetatable(self, meta) + return self +end + +-- we have to save and use the original dfhack.printerr here so our test harness +-- output doesn't trigger its own dfhack.printerr usage detection (see +-- detect_printerr below) +local orig_printerr = dfhack.printerr +local function wrap_expect(func, private, path) + return function(...) + private.checks = private.checks + 1 + local ret = {func(...)} + local ok = table.remove(ret, 1) + if ok then + private.checks_ok = private.checks_ok + 1 + return + end + local msg = '' + for _, part in pairs(ret) do + if part then + msg = msg .. ': ' .. tostring(part) + end + end + msg = msg:sub(3) -- strip leading ': ' + orig_printerr('Check failed! ' .. (msg or '(no message)')) + -- Generate a stack trace with all function calls in the same file as the caller to expect.*() + -- (this produces better stack traces when using helpers in tests) + local frame = 2 + local caller_src + while true do + info = debug.getinfo(frame) + if not info then break end + if not caller_src then + caller_src = info.short_src + end + -- Skip any frames corresponding to C calls, or Lua functions defined in another file + -- these could include pcall(), with_finalize(), etc. + if info.what == 'Lua' and (info.short_src == caller_src or info.short_src == path) then + orig_printerr((' at %s:%d'):format(info.short_src, info.currentline)) + end + frame = frame + 1 + end + print('') + end +end + +local function build_test_env(path) + local env = { + test = TestTable(), + -- config values can be overridden in the test file to define + -- requirements for the tests in that file + config = { + -- override with the required game mode + mode = 'none', + -- override with a test wrapper function with common setup and + -- teardown for every test, if needed. for example: + -- local function test_wrapper(test_fn) + -- mock.patch(dfhack.filesystem, + -- 'listdir_recursive', + -- mock.func({}), + -- test_fn) + -- end + -- config.wrapper = test_wrapper + wrapper = nil, + }, + expect = {}, + mock = mock, + delay = delay, + delay_until = delay_until, + require = clean_require, + reqscript = clean_reqscript, + } + local private = { + checks = 0, + checks_ok = 0, + } + for name, func in pairs(expect) do + env.expect[name] = wrap_expect(func, private, path) + end + setmetatable(env, {__index = _G}) + return env, private +end + +local function get_test_files(test_dir) + local files = {} + print('Loading tests from ' .. test_dir) + for _, entry in ipairs(dfhack.filesystem.listdir_recursive(test_dir)) do + if not entry.isdir then + table.insert(files, entry.path) + end + end + table.sort(files) + return files +end + +local function load_test_status() + if dfhack.filesystem.isfile(STATUS_FILE) then + return json.decode_file(STATUS_FILE) + end +end + +local function save_test_status(status) + json.encode_file(status, STATUS_FILE) +end + +local function finish_tests(done_command) + dfhack.internal.IN_TEST = false + overlay.rescan() + if done_command and #done_command > 0 then + dfhack.run_command(done_command) + end +end + +local function load_tests(file, tests) + local short_filename = file:sub((file:find('test') or -4) + 5, -1) + print('Loading file: ' .. short_filename) + local env, env_private = build_test_env(file) + local code, err = loadfile(file, 't', env) + if not code then + dfhack.printerr('Failed to load file: ' .. tostring(err)) + return false + end + dfhack.internal.IN_TEST = true + local ok, err = dfhack.pcall(code) + dfhack.internal.IN_TEST = false + if not ok then + dfhack.printerr('Error when running file: ' .. tostring(err)) + return false + end + if not MODES[env.config.mode] then + dfhack.printerr('Invalid config.mode: ' .. tostring(env.config.mode)) + return false + end + if not env.config.target then + dfhack.printerr('Skipping tests for unspecified target in ' .. file) + return true -- TODO: change to false once existing tests have targets specified + end + local targets = type(env.config.target) == 'table' and env.config.target or {env.config.target} + for _,target in ipairs(targets) do + if target == 'core' then goto continue end + if type(target) ~= 'string' or helpdb.has_tag(target, 'unavailable') then + dfhack.printerr('Skipping tests for unavailable target: ' .. target) + return true + end + ::continue:: + end + for name, test_func in pairs(env.test) do + if env.config.wrapper then + local fn = test_func + test_func = function() env.config.wrapper(fn) end + end + local test_data = { + full_name = short_filename .. ':' .. name, + func = test_func, + private = env_private, + config = env.config, + } + test_data.name = test_data.full_name:gsub('test/', ''):gsub('.lua', '') + table.insert(tests, test_data) + end + return true +end + +local function sort_tests(tests) + -- to make sort stable + local test_index = utils.invert(tests) + table.sort(tests, function(a, b) + if a.config.mode ~= b.config.mode then + return MODES[a.config.mode].order < MODES[b.config.mode].order + end + return test_index[a] < test_index[b] + end) +end + +local function wrap_test(func) + local saved_printerr = dfhack.printerr + local printerr_called = false + local printerr_wrapper = function(msg) + if msg == nil then return end + saved_printerr(msg) + printerr_called = true + end + + return mock.patch( + { + {dfhack, 'printerr', printerr_wrapper}, + {dfhack, 'run_script', clean_run_script}, + {dfhack, 'reqscript', clean_reqscript}, + }, + function() + local ok, err = dfhack.pcall(func) + if printerr_called then + return false, + "dfhack.printerr was called outside of" .. + " expect.printerr_match(). please wrap your test" .. + " with expect.printerr_match()." + end + return ok, err + end + ) +end + +local function get_elapsed_str(elapsed) + return elapsed < 1 and "<1" or tostring(elapsed) +end + +local function run_test(test, status, counts) + test.private.checks = 0 + test.private.checks_ok = 0 + counts.tests = counts.tests + 1 + dfhack.internal.IN_TEST = true + local start_ms = dfhack.getTickCount() + local ok, err = wrap_test(test.func) + local elapsed_ms = dfhack.getTickCount() - start_ms + dfhack.internal.IN_TEST = false + local passed = false + if not ok then + dfhack.printerr('error: ' .. tostring(err) .. '\n') + dfhack.printerr('test errored: ' .. test.name) + elseif test.private.checks ~= test.private.checks_ok then + dfhack.printerr('test failed: ' .. test.name) + else + local elapsed_str = get_elapsed_str(elapsed_ms) + print(('test passed in %s ms: %s'):format(elapsed_str, test.name)) + passed = true + counts.tests_ok = counts.tests_ok + 1 + end + counts.checks = counts.checks + (tonumber(test.private.checks) or 0) + counts.checks_ok = counts.checks_ok + (tonumber(test.private.checks_ok) or 0) + return passed +end + +local function get_tests(test_files, counts) + local tests = {} + for _, file in ipairs(test_files) do + if not load_tests(file, tests) then + counts.file_errors = counts.file_errors + 1 + end + end + return tests +end + +local function filter_tests(tests, config) + if config.tests or config.modes then + for _,filter in ipairs({{'tests', 'name pattern'},{'modes', 'mode'}}) do + if config[filter[1]] and #config[filter[1]] > 0 then + print(string.format('Filtering tests by %s:', filter[2])) + for _,v in ipairs(config[filter[1]]) do + print(string.format(' %s', v)) + end + end + end + local orig_length = #tests + for i = #tests, 1, -1 do + local remove = false + if config.modes then + remove = true + -- allow test if it matches any of the given modes + for _, mode in pairs(config.modes) do + if tests[i].config.mode == mode then + remove = false + break + end + end + end + if config.tests and not remove then + remove = true + -- allow test if it matches any of the given patterns + for _, pattern in pairs(config.tests) do + if tests[i].name:match(pattern) then + remove = false + break + end + end + end + if remove then table.remove(tests, i) end + end + print('Selected tests: ' .. #tests .. '/' .. orig_length) + end + + local status = {} + if config.resume then + status = load_test_status() or status + for i = #tests, 1, -1 do + local test = tests[i] + if not status[test.full_name] then + status[test.full_name] = TestStatus.PENDING + elseif status[test.full_name] ~= TestStatus.PENDING then + print(('skipping test: %s: state = %s'):format( + test.name, status[test.full_name])) + table.remove(tests, i) + end + end + end + + sort_tests(tests) + return status +end + +local function run_tests(tests, status, counts, config) + wait_for(60000, 'game load', function() + local scr = dfhack.gui.getDFViewscreen() + return not df.viewscreen_initial_prepst:is_instance(scr) + end) + print(('Running %d tests'):format(#tests)) + local start_ms = dfhack.getTickCount() + local num_skipped = 0 + for _, test in pairs(tests) do + if MODES[test.config.mode].failed then + num_skipped = num_skipped + 1 + goto skip + end + if not MODES[test.config.mode].detect() then + print(('Switching to %s mode for test: %s'):format(test.config.mode, test.name)) + local ok, err = pcall(MODES[test.config.mode].navigate, config) + if not ok then + MODES[test.config.mode].failed = true + dfhack.printerr(tostring(err)) + num_skipped = num_skipped + 1 + goto skip + end + end + -- pre-emptively mark the test as failed in case we induce a crash + status[test.full_name] = TestStatus.FAILED + save_test_status(status) + if run_test(test, status, counts) then + status[test.full_name] = TestStatus.PASSED + save_test_status(status) + end + ::skip:: + end + local elapsed_ms = dfhack.getTickCount() - start_ms + + local function print_summary_line(ok, message) + local print_fn = print + if not ok then + status['*'] = TestStatus.FAILED + print_fn = dfhack.printerr + end + print_fn(' ' .. message) + end + + status['*'] = status['*'] or TestStatus.PASSED + print(('\nTests completed in %s ms:'):format(get_elapsed_str(elapsed_ms))) + print_summary_line(counts.tests_ok == counts.tests, + ('%d/%d tests passed'):format(counts.tests_ok, counts.tests)) + print_summary_line(counts.checks_ok == counts.checks, + ('%d/%d checks passed'):format(counts.checks_ok, counts.checks)) + print_summary_line(counts.file_errors == 0, + ('%d test files failed to load'):format(counts.file_errors)) + print_summary_line(num_skipped == 0, + ('%d tests in unreachable modes'):format(num_skipped)) + + save_test_status(status) +end + +local function dump_df_state() + local state = { + enabler = { + fps = df.global.enabler.fps, + gfps = df.global.enabler.gfps, + fullscreen_state = df.global.enabler.fullscreen_state.whole, + }, + gps = { + dimx = df.global.gps.dimx, + dimy = df.global.gps.dimy, + display_frames = df.global.gps.display_frames, + }, + } + json.encode_file(state, DF_STATE_FILE) + print('DF global state: ' .. json.encode(state, {pretty = false})) +end + +local function main(args) + local help, resume, test_dir, mode_filter, save_dir, test_filter = + false, false, nil, {}, nil, {} + local other_args = utils.processArgsGetopt(args, { + {'h', 'help', handler=function() help = true end}, + {'d', 'test_dir', hasArg=true, + handler=function(arg) test_dir = arg end}, + {'m', 'modes', hasArg=true, + handler=function(arg) mode_filter = utils.split_string(arg, ',') end}, + {'r', 'resume', handler=function() resume = true end}, + {'s', 'save_dir', hasArg=true, + handler=function(arg) save_dir = arg end}, + {'t', 'tests', hasArg=true, + handler=function(arg) test_filter = utils.split_string(arg, ',') end}, + }) + + if help then print(help_text) return end + + local done_command = table.concat(other_args, ' ') + local config = load_test_config(CONFIG_FILE) + + -- override config with any params specified on the commandline + if test_dir then config.test_dir = test_dir end + if resume then config.resume = true end + if save_dir then config.save_dir = save_dir end + if #mode_filter > 0 then config.modes = mode_filter end + if #test_filter > 0 then config.tests = test_filter end + if #done_command > 0 then config.done_command = done_command end + + if not dfhack.filesystem.isdir(config.test_dir) then + qerror(('Invalid test folder: "%s"'):format(config.test_dir)) + end + + local counts = { + tests = 0, + tests_ok = 0, + checks = 0, + checks_ok = 0, + file_errors = 0, + } + + dump_df_state() + local test_files = get_test_files(config.test_dir) + local tests = get_tests(test_files, counts) + local status = filter_tests(tests, config) + + script.start(function() + dfhack.call_with_finalizer(1, true, + finish_tests, config.done_command, + run_tests, tests, status, counts, config) + end) +end + +if not dfhack_flags.module then + main({...}) +end diff --git a/ci/update-submodules.bash b/ci/update-submodules.bash new file mode 100755 index 0000000000..3cea29961c --- /dev/null +++ b/ci/update-submodules.bash @@ -0,0 +1,40 @@ +#!/bin/bash + +set -e + +message_file=.git/COMMIT_EDITMSG + +get_git_root() { + git rev-parse --show-toplevel +} + +write_msg() { + echo "$@" >> "${message_file}" +} + +git_root="$(get_git_root)" +cd "${git_root}" +rm -f "${message_file}" +write_msg "Auto-update submodules" +write_msg "" + +cat ci/update-submodules.manifest | while read path branch; do + cd "${git_root}/${path}" + test "${git_root}" != "$(get_git_root)" + git fetch origin "${branch}:${branch}" + git checkout "${branch}" + git branch --set-upstream-to="origin/${branch}" "${branch}" + git pull --ff-only + cd "${git_root}" + if ! git diff --quiet --ignore-submodules=dirty -- "${path}"; then + git add "${path}" + write_msg "${path}: ${branch}" + fi +done + +if ! git diff --exit-code --cached; then + git commit --file "${message_file}" --no-edit + exit 0 +else + exit 1 +fi diff --git a/ci/update-submodules.manifest b/ci/update-submodules.manifest new file mode 100644 index 0000000000..7d2c1412cf --- /dev/null +++ b/ci/update-submodules.manifest @@ -0,0 +1,10 @@ +library/xml master +scripts master +plugins/stonesense master +depends/clsocket master +depends/libzip dfhack +depends/libexpat dfhack +depends/xlsxio dfhack +depends/luacov dfhack +depends/jsoncpp-sub dfhack +depends/dfhooks main diff --git a/conf.py b/conf.py index 10df1b551f..f5dd4451a1 100644 --- a/conf.py +++ b/conf.py @@ -1,4 +1,3 @@ -#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ DFHack documentation build configuration file @@ -15,117 +14,120 @@ # pylint:disable=redefined-builtin -import fnmatch -from io import open -from itertools import starmap +import datetime import os +import re import shlex # pylint:disable=unused-import +import sphinx import sys +sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'docs', 'sphinx_extensions')) +from dfhack.util import write_file_if_changed -# -- Autodoc for DFhack scripts ------------------------------------------- +if os.environ.get('DFHACK_DOCS_BUILD_OFFLINE'): + # block attempted image downloads, particularly for the PDF builder + def request_disabled(*args, **kwargs): + raise RuntimeError('Offline build - network request blocked') -def doc_dir(dirname, files): - """Yield (command, includepath) for each script in the directory.""" + import urllib3.util + urllib3.util.create_connection = request_disabled + + import urllib3.connection + urllib3.connection.HTTPConnection.connect = request_disabled + + import requests + requests.request = request_disabled + requests.get = request_disabled + + +# -- Autodoc for DFhack plugins and scripts ------------------------------- + +def doc_dir(dirname, files, prefix): + """Yield (name, includepath) for each file in the directory.""" sdir = os.path.relpath(dirname, '.').replace('\\', '/').replace('../', '') + if prefix == '.': + prefix = '' + else: + prefix += '/' for f in files: - if f[-3:] not in ('lua', '.rb'): + if f[-4:] != '.rst': continue - with open(os.path.join(dirname, f), 'r', encoding='utf8') as fstream: - text = [l.rstrip() for l in fstream.readlines() if l.strip()] - # Some legacy lua files use the ruby tokens (in 3rdparty scripts) - tokens = ('=begin', '=end') - if f[-4:] == '.lua' and any('[====[' in line for line in text): - tokens = ('[====[', ']====]') - command = None - for line in text: - if command and line == len(line) * '=': - yield command, sdir + '/' + f, tokens[0], tokens[1] - break - command = line - - -def document_scripts(): - """Autodoc for files with the magic script documentation marker strings. - - Returns a dict of script-kinds to lists of .rst include directives. - """ - # First, we collect the commands and paths to include in our docs - scripts = [] - for root, _, files in os.walk('scripts'): - scripts.extend(doc_dir(root, files)) - # Next we split by type and create include directives sorted by command - kinds = {'base': [], 'devel': [], 'fix': [], 'gui': [], 'modtools': []} - for s in scripts: - k_fname = s[0].split('/', 1) - if len(k_fname) == 1: - kinds['base'].append(s) - else: - kinds[k_fname[0]].append(s) - template = '.. _{}:\n\n.. include:: /{}\n' +\ - ' :start-after: {}\n :end-before: {}\n' - return {key: '\n\n'.join(starmap(template.format, sorted(value))) - for key, value in kinds.items()} - -def write_script_docs(): + yield prefix + f[:-4], sdir + '/' + f + + +def doc_all_dirs(): + """Collect the commands and paths to include in our docs.""" + tools = [] + for root, _, files in os.walk('docs/builtins'): + tools.extend(doc_dir(root, files, os.path.relpath(root, 'docs/builtins'))) + for root, _, files in os.walk('docs/plugins'): + tools.extend(doc_dir(root, files, os.path.relpath(root, 'docs/plugins'))) + for root, _, files in os.walk('scripts/docs'): + tools.extend(doc_dir(root, files, os.path.relpath(root, 'scripts/docs'))) + return tuple(tools) + + +def write_tool_docs(): """ - Creates a file for eack kind of script (base/devel/fix/gui/modtools) - with all the ".. include::" directives to pull out docs between the - magic strings. + Creates a file for each tool with the ".. include::" directives to pull in + the original documentation. """ - kinds = document_scripts() - if not os.path.isdir('docs/_auto'): - os.mkdir('docs/_auto') - head = { - 'base': 'Basic Scripts', - 'devel': 'Development Scripts', - 'fix': 'Bugfixing Scripts', - 'gui': 'GUI Scripts', - 'modtools': 'Scripts for Modders'} - for k in head: - title = ('.. _{k}:\n\n{l}\n{t}\n{l}\n\n' - '.. include:: /scripts/{a}about.txt\n\n' - '.. contents::\n\n').format( - k=k, t=head[k], - l=len(head[k])*'#', - a=('' if k == 'base' else k + '/') - ) - mode = 'w' if sys.version_info.major > 2 else 'wb' - with open('docs/_auto/{}.rst'.format(k), mode) as outfile: - outfile.write(title) - outfile.write(kinds[k]) - - -# Actually call the docs generator -write_script_docs() + for k in doc_all_dirs(): + label = ('.. _{name}:\n\n').format(name=k[0]) + include = ('.. include:: /{path}\n\n').format(path=k[1]) + os.makedirs(os.path.join('docs/tools', os.path.dirname(k[0])), + mode=0o755, exist_ok=True) + with write_file_if_changed('docs/tools/{}.rst'.format(k[0])) as outfile: + outfile.write(label) + outfile.write(include) + + +write_tool_docs() # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. -needs_sphinx = '1.3' +needs_sphinx = '3.4.3' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. -extensions = ['sphinx.ext.extlinks'] +extensions = [ + 'sphinx.ext.extlinks', + 'dfhack.changelog', + 'dfhack.lexer', + 'dfhack.tool_docs', +] + +sphinx_major_version = sphinx.version_info[0] + +def get_caption_str(prefix=''): + return prefix + (sphinx_major_version >= 5 and '%s' or '') # This config value must be a dictionary of external sites, mapping unique # short alias names to a base URL and a prefix. # See http://sphinx-doc.org/ext/extlinks.html extlinks = { - 'wiki': ('http://dwarffortresswiki.org/%s', ''), + 'wiki': ('https://dwarffortresswiki.org/%s', get_caption_str()), 'forums': ('http://www.bay12forums.com/smf/index.php?topic=%s', - 'Bay12 forums thread '), - 'dffd': ('http://dffd.bay12games.com/file.php?id=%s', 'DFFD file '), - 'bug': ('http://www.bay12games.com/dwarves/mantisbt/view.php?id=%s', - 'Bug '), - 'issue': ('https://github.com/DFHack/dfhack/issues/%s', 'Issue '), - 'commit': ('https://github.com/DFHack/dfhack/commit/%s', 'Commit '), + get_caption_str('Bay12 forums thread ')), + 'dffd': ('https://dffd.bay12games.com/file.php?id=%s', + get_caption_str('DFFD file ')), + 'bug': ('https://dwarffortressbugtracker.com/view.php?id=%s', + get_caption_str('Bug ')), + 'source': ('https://github.com/DFHack/dfhack/tree/develop/%s', + get_caption_str()), + 'source-scripts': ('https://github.com/DFHack/scripts/tree/master/%s', + get_caption_str()), + 'issue': ('https://github.com/DFHack/dfhack/issues/%s', + get_caption_str('Issue ')), + 'commit': ('https://github.com/DFHack/dfhack/commit/%s', + get_caption_str('Commit ')), } # Add any paths that contain templates here, relative to this directory. -templates_path = [] +templates_path = ["docs/templates"] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: @@ -139,7 +141,7 @@ def write_script_docs(): # General information about the project. project = 'DFHack' -copyright = '2015, The DFHack Team' +copyright = '2015-%d, The DFHack Team' % datetime.datetime.now().year author = 'The DFHack Team' # The version info for the project you're documenting, acts as replacement for @@ -149,13 +151,15 @@ def write_script_docs(): def get_version(): """Return the DFHack version string, from CMakeLists.txt""" version = release = '' #pylint:disable=redefined-outer-name + pattern = re.compile(r'set\((df_version|dfhack_release)\s+"(.+?)"\)') try: with open('CMakeLists.txt') as f: for s in f.readlines(): - if fnmatch.fnmatch(s.upper(), 'SET(DF_VERSION "?.??.??")\n'): - version = s.upper().replace('SET(DF_VERSION "', '') - elif fnmatch.fnmatch(s.upper(), 'SET(DFHACK_RELEASE "r*")\n'): - release = s.upper().replace('SET(DFHACK_RELEASE "', '').lower() + for match in pattern.findall(s.lower()): + if match[0] == 'df_version': + version = match[1] + elif match[0] == 'dfhack_release': + release = match[1] return (version + '-' + release).replace('")\n', '') except IOError: return 'unknown' @@ -168,7 +172,7 @@ def get_version(): # for a list of supported languages. # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. -language = None +language = 'en' # strftime format for |today| and 'Last updated on:' timestamp at page bottom today_fmt = html_last_updated_fmt = '%Y-%m-%d' @@ -177,9 +181,19 @@ def get_version(): # directories to ignore when looking for source files. exclude_patterns = [ 'README.md', - 'docs/html*', - 'depends/*', + '.git/*', 'build*', + 'depends/*', + 'docs/html/*', + 'docs/tags/*', + 'docs/text/*', + 'docs/builtins/*', + 'docs/pdf/*', + 'docs/plugins/*', + 'docs/pseudoxml/*', + 'docs/xml/*', + 'scripts/docs/*', + 'plugins/*', ] # The reST default role (used for this markup: `text`) to use for all @@ -189,26 +203,36 @@ def get_version(): # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' +# The default language to highlight source code in. +highlight_language = 'dfhack' + # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False +rst_prolog = """ +.. |sphinx_min_version| replace:: {sphinx_min_version} +.. |dfhack_version| replace:: {dfhack_version} +""".format( + sphinx_min_version=needs_sphinx, + dfhack_version=version, +) # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'alabaster' -html_style = 'dfhack.css' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. html_theme_options = { - #'logo': 'logo.png', + 'logo': 'dfhack-logo.png', 'github_user': 'DFHack', 'github_repo': 'dfhack', 'github_button': False, 'travis_button': False, + 'fixed_sidebar': True, } # The name for this set of Sphinx documents. If None, it defaults to @@ -232,6 +256,10 @@ def get_version(): # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['docs/styles'] +# A list of paths that contain extra files not directly related to the +# documentation. +html_extra_path = ['robots.txt'] + # Custom sidebar templates, maps document names to template names. html_sidebars = { '**': [ @@ -242,11 +270,19 @@ def get_version(): ] } -# If false, no module index is generated. -html_domain_indices = False - -# If false, no index is generated. +# generate domain indices but not the (unused) genindex html_use_index = False +html_domain_indices = True + +# don't link to rst sources in the generated pages +html_show_sourcelink = False + +html_css_files = [ + 'dfhack.css', +] + +if sphinx_major_version >= 5: + html_css_files.append('sphinx5.css') # -- Options for LaTeX output --------------------------------------------- @@ -257,3 +293,17 @@ def get_version(): (master_doc, 'DFHack.tex', 'DFHack Documentation', 'The DFHack Team', 'manual'), ] + +latex_toplevel_sectioning = 'part' + +# -- Options for text output --------------------------------------------- + +from sphinx.writers import text + +# this value is arbitrary. it just needs to be bigger than the number of +# characters in the longest paragraph in the DFHack docs +text.MAXWIDTH = 1000000000 + +# this is the order that section headers will use the characters for underlines +# they are in the order of (subjective) text-mode readability +text_sectionchars = '=-~`+"*' diff --git a/data/CMakeLists.txt b/data/CMakeLists.txt new file mode 100644 index 0000000000..75146071b8 --- /dev/null +++ b/data/CMakeLists.txt @@ -0,0 +1,34 @@ +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/dfhack-config/ + DESTINATION "${DFHACK_DATA_DESTINATION}/data/dfhack-config-defaults") + +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/init/ + DESTINATION "${DFHACK_DATA_DESTINATION}/init") + +install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/base_command_counts.json + DESTINATION "${DFHACK_DATA_DESTINATION}/data") + +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/orders/ + DESTINATION "${DFHACK_DATA_DESTINATION}/data/orders") + +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/stockpiles/ + DESTINATION "${DFHACK_DATA_DESTINATION}/data/stockpiles") + +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/art/ + DESTINATION "${DFHACK_DATA_DESTINATION}/data/art") + +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/professions/ + DESTINATION "${DFHACK_DATA_DESTINATION}/data/professions") + +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/blueprints/ + DESTINATION "${DFHACK_DATA_DESTINATION}/data/blueprints" + FILES_MATCHING PATTERN "*" + PATTERN blueprints/test EXCLUDE) + +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/patches/ + DESTINATION ${DFHACK_DATA_DESTINATION}/patches +) + +if(BUILD_TESTS) + install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/blueprints/test/ + DESTINATION "${DFHACK_DATA_DESTINATION}/data/blueprints/test") +endif() diff --git a/data/art/border-bold.png b/data/art/border-bold.png new file mode 100644 index 0000000000..16423a3a74 Binary files /dev/null and b/data/art/border-bold.png differ diff --git a/data/art/border-medium.png b/data/art/border-medium.png new file mode 100644 index 0000000000..529a60ee43 Binary files /dev/null and b/data/art/border-medium.png differ diff --git a/data/art/border-panel.png b/data/art/border-panel.png new file mode 100644 index 0000000000..52b24b9199 Binary files /dev/null and b/data/art/border-panel.png differ diff --git a/data/art/border-thin.png b/data/art/border-thin.png new file mode 100644 index 0000000000..71fa59a3ea Binary files /dev/null and b/data/art/border-thin.png differ diff --git a/data/art/border-window.png b/data/art/border-window.png new file mode 100644 index 0000000000..34747d69b7 Binary files /dev/null and b/data/art/border-window.png differ diff --git a/data/art/control-panel.png b/data/art/control-panel.png new file mode 100644 index 0000000000..2f5e9468af Binary files /dev/null and b/data/art/control-panel.png differ diff --git a/data/art/curses-small-letters_top-left.png b/data/art/curses-small-letters_top-left.png new file mode 100644 index 0000000000..2bf2e5aff2 Binary files /dev/null and b/data/art/curses-small-letters_top-left.png differ diff --git a/data/art/damp_dig_map.png b/data/art/damp_dig_map.png new file mode 100644 index 0000000000..db82f1a1b0 Binary files /dev/null and b/data/art/damp_dig_map.png differ diff --git a/data/art/damp_dig_toolbar.png b/data/art/damp_dig_toolbar.png new file mode 100644 index 0000000000..4c2c1939e6 Binary files /dev/null and b/data/art/damp_dig_toolbar.png differ diff --git a/data/art/design.png b/data/art/design.png new file mode 100644 index 0000000000..38fed7e088 Binary files /dev/null and b/data/art/design.png differ diff --git a/data/art/design_toolbar.png b/data/art/design_toolbar.png new file mode 100644 index 0000000000..935a332f00 Binary files /dev/null and b/data/art/design_toolbar.png differ diff --git a/data/art/green-pin.png b/data/art/green-pin.png new file mode 100644 index 0000000000..25d0e696ff Binary files /dev/null and b/data/art/green-pin.png differ diff --git a/data/art/icons.png b/data/art/icons.png new file mode 100644 index 0000000000..141d9f79f4 Binary files /dev/null and b/data/art/icons.png differ diff --git a/data/art/logo.png b/data/art/logo.png new file mode 100644 index 0000000000..c34407b372 Binary files /dev/null and b/data/art/logo.png differ diff --git a/data/art/mass_remove_toolbar.png b/data/art/mass_remove_toolbar.png new file mode 100644 index 0000000000..d1b09ac93b Binary files /dev/null and b/data/art/mass_remove_toolbar.png differ diff --git a/data/art/note_green_pin_map.png b/data/art/note_green_pin_map.png new file mode 100644 index 0000000000..b692263f90 Binary files /dev/null and b/data/art/note_green_pin_map.png differ diff --git a/data/art/on-off.png b/data/art/on-off.png new file mode 100644 index 0000000000..2b731e1c6b Binary files /dev/null and b/data/art/on-off.png differ diff --git a/data/art/on-off_top-left.png b/data/art/on-off_top-left.png new file mode 100644 index 0000000000..7303ff10d4 Binary files /dev/null and b/data/art/on-off_top-left.png differ diff --git a/data/art/pathable.png b/data/art/pathable.png new file mode 100644 index 0000000000..00f7f831d1 Binary files /dev/null and b/data/art/pathable.png differ diff --git a/data/art/red-pin.png b/data/art/red-pin.png new file mode 100644 index 0000000000..763b83e97e Binary files /dev/null and b/data/art/red-pin.png differ diff --git a/data/art/sitemap_toolbar.png b/data/art/sitemap_toolbar.png new file mode 100644 index 0000000000..a29fa9b900 Binary files /dev/null and b/data/art/sitemap_toolbar.png differ diff --git a/data/art/tiletypes.png b/data/art/tiletypes.png new file mode 100644 index 0000000000..9411c7c91d Binary files /dev/null and b/data/art/tiletypes.png differ diff --git a/data/art/unsuspend.png b/data/art/unsuspend.png new file mode 100644 index 0000000000..f1d1d33da6 Binary files /dev/null and b/data/art/unsuspend.png differ diff --git a/data/base_command_counts.json b/data/base_command_counts.json new file mode 100644 index 0000000000..a05d50c1ed --- /dev/null +++ b/data/base_command_counts.json @@ -0,0 +1,145 @@ +{ + "manipulator": 75, + "autolabor": 59, + "reveal": 51, + "help": 50, + "ls": 50, + "die": 50, + "tags": 50, + "embark-assistant": 42, + "prospect": 37, + "autodump": 36, + "clean": 35, + "gui/workflow": 28, + "workflow": 28, + "exportlegends": 26, + "gui/autobutcher": 25, + "autobutcher": 25, + "digv": 24, + "fastdwarf": 22, + "autonestbox": 20, + "showmood": 19, + "gui/liquids": 18, + "liquids": 18, + "search": 18, + "gui/quickfort": 15, + "quickfort": 15, + "createitem": 14, + "stocks": 14, + "autofarm": 12, + "autochop": 12, + "tiletypes": 12, + "exterminate": 12, + "buildingplan": 12, + "quicksave": 11, + "gui/gm-editor": 11, + "cleanowned": 10, + "gui/autogems": 9, + "autogems": 9, + "stonesense": 9, + "gui/stockpiles": 8, + "stockpiles": 8, + "changevein": 8, + "gui/teleport": 7, + "teleport": 7, + "seedwatch": 6, + "automelt": 6, + "embark-tools": 6, + "cursecheck": 5, + "open-legends": 5, + "ban-cooking": 5, + "burial": 5, + "automaterial": 5, + "remove-stress": 5, + "gui/blueprint": 5, + "blueprint": 5, + "tailor": 4, + "startdwarf": 4, + "3dveins": 4, + "digcircle": 4, + "nestboxes": 3, + "deathcause": 3, + "list-agreements": 3, + "gui/room-list": 3, + "points": 3, + "region-pops": 3, + "gui/advfort": 3, + "unsuspend": 3, + "locate-ore": 3, + "changelayer": 3, + "source": 3, + "gui/gm-unit": 3, + "combine-drinks": 3, + "combine-plants": 3, + "deteriorate": 3, + "warn-starving": 3, + "gaydar": 2, + "gui/dfstatus": 2, + "gui/rename": 2, + "rename": 2, + "fix-ster": 2, + "job-material": 2, + "stockflow": 2, + "drain-aquifer": 2, + "full-heal": 2, + "spawnunit": 2, + "flashstep": 2, + "gui/family-affairs": 2, + "caravan": 2, + "mousequery": 2, + "tweak": 2, + "confirm": 2, + "autoclothing": 1, + "autounsuspend": 1, + "prioritize": 1, + "dwarfmonitor": 1, + "show-unit-syndromes": 1, + "troubleshoot-item": 1, + "gui/mechanisms": 1, + "gui/pathable": 1, + "hotkeys": 1, + "infinite-sky": 1, + "force": 1, + "hermit": 1, + "strangemood": 1, + "weather": 1, + "add-recipe": 1, + "autotrade": 1, + "zone": 1, + "autonick": 1, + "stripcaged": 1, + "unforbid": 1, + "workorder": 1, + "gui/mod-manager": 1, + "spotclean": 1, + "plant": 1, + "regrass": 1, + "dig-now": 1, + "build-now": 1, + "clear-webs": 1, + "gui/siege-engine": 1, + "assign-skills": 1, + "brainwash": 1, + "elevate-mental": 1, + "elevate-physical": 1, + "launch": 1, + "linger": 1, + "make-legendary": 1, + "rejuvenate": 1, + "resurrect-adv": 1, + "questport": 1, + "getplants": 1, + "gui/stamper": 1, + "tweak": 1, + "fixveins": 1, + "deramp": 1, + "fix/dead-units": 1, + "fix/fat-dwarves": 1, + "fix/loyaltycascade": 1, + "fix/retrieve-units": 1, + "tweak": 1, + "sort-items": 1, + "gui/color-schemes": 1, + "color-schemes": 1, + "season-palette": 1 +} diff --git a/data/blueprints/aquifer_tap.csv b/data/blueprints/aquifer_tap.csv new file mode 100644 index 0000000000..dc79e523d4 --- /dev/null +++ b/data/blueprints/aquifer_tap.csv @@ -0,0 +1,73 @@ +#notes label(help) +"This blueprint will help you get a safe, everlasting source of fresh water from a light aquifer. See https://youtu.be/hF3_fjLc_EU for a video tutorial." +"" +Here's the procedure: +"" +"1) Locate an area with a light aquifer. DFHack gives light aquifer tiles a two-drop icon that appears when you are in mining mode. If you dug through it on the way down, take note of the elevations where it's likely to be (but be aware that there is regional variation and there's no guarantee that it exists on the map where you want it to be). If you are having trouble finding the boundaries of your aquifer, you can run prospect all --show features to discover the general elevations or gui/reveal -o to see the actual tiles." +"" +2) Dig a one-tile-wide tunnel from where you want the water to end up (e.g. your well cistern) to an area on the same z-level directly below the target light aquifer. Dig a one-tile-wide diagonal segment in this tunnel near the cistern side so water that will eventually flow through the tunnel is depressurized. +"" +"3) Pause the game. From the end of that tunnel, go down one z-level then designate for digging a staircase straight up so that the top is in the lowest aquifer level (a tile with a two-drop icon). Your original tunnel should connect to the staircase one z-level above the bottom of the staircase." +"" +"4) Apply this blueprint (gui/quickfort aquifer_tap /dig) to the z-level at the top of the staircase. The tiles will be designated in ""damp dig"" mode so your miners can dig it out without the damp tiles canceling the digging designations. This blueprint also changes the staircase tile below the tap to a vanilla ""blueprint"" tile (shaded in blue) so your miners don't dig the tap before your drainage tunnel is ready." +"" +"5) You can now unpause the game. From the bottom of the staircase (the z-level below where the water will flow to your cisterns), dig a straight, one-tile wide tunnel to the closest edge of the map. This is your emergency drainage tunnel. Smooth the map edge tile and carve a fortification. The water can flow through the fortification and off the map, allowing the dwarves to dig out the aquifer tap without drowning." +"" +6) Place a lever-controlled floodgate in the drainage tunnel and open the floodgate. Place the lever somewhere else in your fort so that it will remain dry and accessible. +"" +"7) If you want, haul away any boulders in the tunnels and/or smooth the tiles (e.g. mark them for dumping -- hotkey i-p -- and wait for them to be dumped). Enable prioritize in gui/control-panel to focus dwarves on dumping tasks and make it go faster. You won't be able to access any of this area once it fills up with water!" +"" +"8) Convert the ""blueprint"" stairway tile to a regular up/down stair dig designation to allow your miners to dig out the tap. You can haul away any boulders if you like. There is no rush. The water will safely flow down the staircase, through the open floodgate, down the drainage tunnel, and off the map as long as the floodgate is open." +"8b) Sometimes, DF gets into a bad state with mining designations and miners will refuse to dig the stairway tile. If this happens to you, enter mining mode, enable the keyboard cursor if it's not already enabled (hotkey: Alt-k), highlight the undug stair designation, and run dig-now here in gui/launcher. You might also have to do this for the down stair designation in the center of the aquifer tap. Your miners should be able to handle the rest without assistance." + +"9) Once everything is dug out and all dwarves are out of the waterways, close the floodgate. Your cisterns will fill with water. Since the waterway to your cisterns is depressurized (due to the diagonal tunnel you dug), the cisterns will stay forever full, but will not flood." +"" +A diagram might be useful. Here is a vertical view through the z-levels. This blueprint goes at the top: +"" +"j <- down stairs, center of this blueprint" +"i <- up/down stairs, initially in ""blueprint mode"" to prevent digging before drainage is ready" +"... <- up/down stairs, make this as tall as you need" +i +i <- cistern outlet level with diagonal tunnel to depressurize +"u <- up stairs, drainage level" +"" +"Good luck! If done right, this method is the safest way to supply your fort with clean water." +#dig label(dig) start(10 10 center of tap) light aquifer water collector +,,,,,,,,,,,,,,,,,, +,,,,,,,,mdd3,mdd3,mdd3,,,,,,,, +,,,,,,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,,,,,, +,,,,mdd3,,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,,mdd3,,,, +,,,mdd3,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,mdd3,,, +,,mdd3,,,mdd3,mdd3,,mdd3,mdd3,mdd3,,mdd3,mdd3,,,mdd3,, +,,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,, +,,,mdd3,mdd3,,,mdd3,mdd3,,mdd3,mdd3,,,mdd3,mdd3,,, +,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3, +,mdd3,mdd3,,,mdd3,mdd3,,,mdj3,,,mdd3,mdd3,,,mdd3,mdd3, +,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3, +,,,mdd3,mdd3,,,mdd3,mdd3,,mdd3,mdd3,,,mdd3,mdd3,,, +,,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,mdd3,, +,,mdd3,,,mdd3,mdd3,,mdd3,mdd3,mdd3,,mdd3,mdd3,,,mdd3,, +,,,mdd3,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,mdd3,,, +,,,,mdd3,,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,,mdd3,,,, +,,,,,,mdd3,mdd3,mdd3,,mdd3,mdd3,mdd3,,,,,, +,,,,,,,,mdd3,mdd3,mdd3,,,,,,,, +,,,,,,,,,,,,,,,,,, +#>,,,,,,,,,,,,,,,,,, +,,,,,,,,,,,,,,,,,, +,,,,,,,,`,`,`,,,,,,,, +,,,,,,`,`,`,,`,`,`,,,,,, +,,,,`,,`,`,`,,`,`,`,,`,,,, +,,,`,`,`,`,,`,`,`,,`,`,`,`,,, +,,`,,,`,`,,`,`,`,,`,`,,,`,, +,,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,, +,,,`,`,,,`,`,,`,`,,,`,`,,, +,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`, +,`,`,,,`,`,,,mbmdi3,,,`,`,,,`,`, +,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`, +,,,`,`,,,`,`,,`,`,,,`,`,,, +,,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,, +,,`,,,`,`,,`,`,`,,`,`,,,`,, +,,,`,`,`,`,,`,`,`,,`,`,`,`,,, +,,,,`,,`,`,`,,`,`,`,,`,,,, +,,,,,,`,`,`,,`,`,`,,,,,, +,,,,,,,,`,`,`,,,,,,,, diff --git a/data/blueprints/bedrooms/28-3-Modified_Windmill_Villas.csv b/data/blueprints/bedrooms/28-3-Modified_Windmill_Villas.csv new file mode 100644 index 0000000000..af15f0cc4f --- /dev/null +++ b/data/blueprints/bedrooms/28-3-Modified_Windmill_Villas.csv @@ -0,0 +1,74 @@ +"#dig label(dig) start(12; 12) 28 bedrooms, 3 tiles each" + +,,,,,,,d,,,,,,d +,,,,,,,d,,,,,,d +,,,,,d,,d,,d,,d,,d,,d +,,,,,d,,d,,d,,d,,d,,d +,,,,,d,d,d,d,d,,d,d,d,,d,,d,d,d +,,,,,,,d,,,,,,d,d,,,d +,,,d,d,d,,d,,d,d,d,,d,d,d,d,d,d,d,d,d +,,,,,,d,d,,,,d,,d,,,,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,,d,,d,d,d +,,,,,d,,,,d,~,~,~,d,,d +,,,d,d,d,,d,d,d,~,~,~,d,d,d,,d,d,d +,,,,,,,d,,d,~,~,~,d,,,,d +,,,d,d,d,,d,,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,d,,,,d,,d,,,,d,d +,d,d,d,d,d,d,d,d,d,,d,d,d,,d,,d,d,d +,,,,,d,,,d,d,,,,,,d +,,,d,d,d,,d,,d,d,d,,d,d,d,d,d +,,,,,,,d,,d,,d,,d,,d,,d +,,,,,,,d,,d,,d,,d,,d,,d +,,,,,,,,,d,,,,,,d +,,,,,,,,,d,,,,,,d + +#meta label(rooms) +zone/zone +build/build +#zone label(zone) start(12; 12) hidden() +,,,,,,b(3x5),,,,,,b(3x5) +,,,,,,,`,,,,,,` +,,,,b(3x5),,,`,b(3x5),,b(3x5),,,`,b(3x5) +,,,,,`,,`,,`,,`,,`,,` +,,,,,`,,`,,`,,`,,`,,`,b(5x3) +,,,,,`,`,`,`,`,,`,`,`,,`,,`,`,` +,,b(5x3),,,,,`,b(5x3),,,,,`,`,,,`,b(5x3) +,,,`,`,`,,`,,`,`,`,,`,`,`,`,`,`,`,`,` +b(5x3),,,,,,`,`,,,,`,,`,b(3x5),,b(5x3),` +,`,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,` +,,b(5x3),,,`,b(3x5),,,`,`,`,`,`,,`,b(5x3) +,,,`,`,`,,`,`,`,`,`,`,`,`,`,,`,`,` +,,b(5x3),,,,,`,,`,`,`,`,`,,,,`,b(5x3) +,,,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,` +b(5x3),,,,,`,,,,`,b(5x3),`,,,,`,b(5x3) +,`,`,`,`,`,`,`,`,`,,`,`,`,,`,,`,`,` +,,b(5x3),,,`,b(3x5),,`,`,b(3x5),,b(3x5),,,`,b(3x5) +,,,`,`,`,,`,,`,`,`,,`,`,`,`,` +,,,,,,,`,b(3x5),`,,`,,`,b(3x5),`,,` +,,,,,,,`,,`,,`,,`,,`,,` +,,,,,,,,,`,,,,,,` +,,,,,,,,,`,,,,,,` + +#build label(build) start(12; 12) hidden() + +,,,,,,,f,,,,,,f +,,,,,,,h,,,,,,h +,,,,,f,,b,,f,,f,,b,,f +,,,,,h,,d,,h,,h,,d,,h +,,,,,b,d,`,d,b,,b,d,`,,b,,b,h,f +,,,,,,,`,,,,,,`,d,,,d +,,,f,h,b,,`,,f,h,b,,`,`,`,`,`,d,b,h,f +,,,,,,d,`,,,,d,,`,,,,d +,f,h,b,d,`,`,`,`,`,`,`,`,`,,f,,b,h,f +,,,,,d,,,,`,`,`,`,`,,h +,,,f,h,b,,b,d,`,`,`,`,`,d,b,,b,h,f +,,,,,,,h,,`,`,`,`,`,,,,d +,,,f,h,b,,f,,`,`,`,`,`,`,`,`,`,d,b,h,f +,,,,,d,,,,`,,d,,,,`,d +,f,h,b,d,`,`,`,`,`,,b,h,f,,`,,b,h,f +,,,,,d,,,d,`,,,,,,` +,,,f,h,b,,b,,`,d,b,,b,d,`,d,b +,,,,,,,h,,d,,h,,h,,d,,h +,,,,,,,f,,b,,f,,f,,b,,f +,,,,,,,,,h,,,,,,h +,,,,,,,,,f,,,,,,f diff --git a/data/blueprints/bedrooms/48-4-Raynard_Whirlpool_Housing.csv b/data/blueprints/bedrooms/48-4-Raynard_Whirlpool_Housing.csv new file mode 100644 index 0000000000..ae7d83f6ec --- /dev/null +++ b/data/blueprints/bedrooms/48-4-Raynard_Whirlpool_Housing.csv @@ -0,0 +1,209 @@ +"#dig label(dig) start(17; 17) 48 rooms, 4 tiles each" + +,,,,,,,,,,,,,,d,,,,d +,,,,,d,,,,d,,,,d,d,d,d,d,d,d,,,,d,,,,d +,,,,d,d,d,d,d,d,d,,,,d,,d,,d,,,,d,d,d,d,d,d,d +,,d,,,d,,d,,d,,,d,,,,d,,,,d,,,d,,d,,d,,,d +,d,d,d,,,,d,,,,d,d,d,,d,d,d,,d,d,d,,,,d,,,,d,d,d +,,d,,,d,d,d,d,d,,,d,,,d,d,d,,,d,,,d,d,d,d,d,,,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,,d,d,d,d,d,,,d,,,d,d,d,,,d,,,d,d,d,d,d,,,d +,d,d,d,,,,d,,,,d,d,d,,d,d,d,,d,d,d,,,,d,,,,d,d,d +,,d,,,d,,d,,d,,,d,,,,d,,,,d,,,d,,d,,d,,,d +,,,,d,d,d,d,d,d,d,,,,d,,d,,d,,,,d,d,d,d,d,d,d +,,,,,d,,d,,d,,,,d,d,d,d,d,d,d,,,,d,,d,,d +,,,d,,,,d,,,,d,,,d,,d,,d,,,d,,,,d,,,,d +,,d,d,d,,d,d,d,,d,d,d,,,,d,,,,d,d,d,,d,d,d,,d,d,d +,,,d,,,d,d,d,,,d,,,d,~,~,~,d,,,d,,,d,d,d,,,d +,,,d,d,d,d,d,d,d,d,d,d,d,d,~,~,~,d,d,d,d,d,d,d,d,d,d,d,d +,,,d,,,d,d,d,,,d,,,d,~,~,~,d,,,d,,,d,d,d,,,d +,,d,d,d,,d,d,d,,d,d,d,,,,d,,,,d,d,d,,d,d,d,,d,d,d +,,,d,,,,d,,,,d,,,d,,d,,d,,,d,,,,d,,,,d +,,,,,d,,d,,d,,,,d,d,d,d,d,d,d,,,,d,,d,,d +,,,,d,d,d,d,d,d,d,,,,d,,d,,d,,,,d,d,d,d,d,d,d +,,d,,,d,,d,,d,,,d,,,,d,,,,d,,,d,,d,,d,,,d +,d,d,d,,,,d,,,,d,d,d,,d,d,d,,d,d,d,,,,d,,,,d,d,d +,,d,,,d,d,d,d,d,,,d,,,d,d,d,,,d,,,d,d,d,d,d,,,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,,d,d,d,d,d,,,d,,,d,d,d,,,d,,,d,d,d,d,d,,,d +,d,d,d,,,,d,,,,d,d,d,,d,d,d,,d,d,d,,,,d,,,,d,d,d +,,d,,,d,,d,,d,,,d,,,,d,,,,d,,,d,,d,,d,,,d +,,,,d,d,d,d,d,d,d,,,,d,,d,,d,,,,d,d,d,d,d,d,d +,,,,,d,,,,d,,,,d,d,d,d,d,d,d,,,,d,,,,d +,,,,,,,,,,,,,,d,,,,d + +#meta label(rooms) +zone1/zone1 +zone2/zone2 +zone3/zone3 +zone4/zone4 +build/build +#zone label(zone1) start(17; 17) hidden() + +,,,,,,,,,,,,,,`,,,,` +,,,,,`,,,,`,,,,`,,`,,`,,`,,,,`,,,,` +,b,b,b,`,,`,,`,,`,b,b,b,`,,,,`,b,b,b,`,,`,,`,,`,b,b,b +b,b,b,b,b,`,,,,`,b,b,b,b,b,,,,b,b,b,b,b,`,,,,`,b,b,b,b,b +b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b +b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b +,,,,,,,`,,,,,,,,,`,,,,,,,,,` +,,`,,,,,,,,,,`,,,,,,,,`,,,,,,,,,,` +,`,,`,,,,,,,,`,,`,,,,,,`,,`,,,,,,,,`,,` +,,`,,,`,,,,`,,,`,,,,,,,,`,,,`,,,,`,,,` +,,,,`,,`,,`,,`,,,,`,,,,`,,,,`,,`,,`,,` +,,b,b,b,`,,,,`,b,b,b,`,,`,,`,,`,b,b,b,`,,,,`,b,b,b +,b,b,b,b,b,,,,b,b,b,b,b,`,,,,`,b,b,b,b,b,,,,b,b,b,b,b +,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b +,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b +,,,,,,,`,,,,,,,,,,,,,,,,,,` +,,,`,,,,,,,,`,,,,,,,,,,`,,,,,,,,` +,,`,,`,,,,,,`,,`,,,,,,,,`,,`,,,,,,`,,` +,,,`,,,,,,,,`,,,`,,,,`,,,`,,,,,,,,` +,,,,,`,,,,`,,,,`,,`,,`,,`,,,,`,,,,` +,b,b,b,`,,`,,`,,`,b,b,b,`,,,,`,b,b,b,`,,`,,`,,`,b,b,b +b,b,b,b,b,`,,,,`,b,b,b,b,b,,,,b,b,b,b,b,`,,,,`,b,b,b,b,b +b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b +b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b +,,,,,,,`,,,,,,,,,`,,,,,,,,,` +,,`,,,,,,,,,,`,,,,,,,,`,,,,,,,,,,` +,`,,`,,,,,,,,`,,`,,,,,,`,,`,,,,,,,,`,,` +,,`,,,`,,,,`,,,`,,,,,,,,`,,,`,,,,`,,,` +,,,,`,,`,,`,,`,,,,`,,,,`,,,,`,,`,,`,,` +,,,,,`,,,,`,,,,`,,`,,`,,`,,,,`,,,,` +,,,,,,,,,,,,,,`,,,,` + +#zone label(zone2) start(17; 17) hidden() +,,,,,,,,,,,,,b,b,b +,,,,b,b,b,,,,,,b,b,b,b,,,`,,,,b,b,b +,,,b,b,b,b,,,`,,,b,b,b,b,,`,,`,,b,b,b,b,,,` +,~,~,b,b,b,b,,`,,`,~,b,b,b,b,,,`,~,~,b,b,b,b,,`,,`,~,~,~ +~,~,~,b,b,b,b,,,`,~,~,~,b,b,b,,,~,~,~,b,b,b,b,,,`,~,~,~,~,~ +~,~,~,~,b,b,b,,,,~,~,~,~,~,,,,~,~,~,~,b,b,b,,,,~,~,~,~,~ +~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~ +,~,~,~,,,,`,,,,~,~,~,,,`,,,~,~,~,,,,`,,,,~,~,~ +,,`,,,,,,,,,,`,,,,,,,,`,,,,,,,,,,` +,`,,`,b,b,b,,,,,`,,`,,,,,,`,,`,b,b,b,,,,,`,,` +,,`,b,b,b,b,,,`,,,`,b,b,b,,,,,`,b,b,b,b,,,`,,,` +,,,b,b,b,b,,`,,`,,b,b,b,b,,,`,,,b,b,b,b,,`,,` +,,~,b,b,b,b,,,`,~,~,b,b,b,b,,`,,`,~,b,b,b,b,,,`,~,~,~ +,~,~,~,b,b,b,,,~,~,~,b,b,b,b,,,`,~,~,~,b,b,b,,,~,~,~,~,~ +,~,~,~,~,~,,,,~,~,~,~,b,b,b,,,,~,~,~,~,~,,,,~,~,~,~,~ +,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~ +,,~,~,~,,,`,,,~,~,~,,,,,,,,~,~,~,,,`,,,~,~,~ +,,,`,,,,,,,,`,,,,,,,,,,`,,,,,,,,` +,,`,,`,,,,,,`,,`,b,b,b,,,,,`,,`,,,,,,`,,` +,,,`,b,b,b,,,,,`,b,b,b,b,,,`,,,`,b,b,b,,,,,` +,,,b,b,b,b,,,`,,,b,b,b,b,,`,,`,,b,b,b,b,,,` +,~,~,b,b,b,b,,`,,`,~,b,b,b,b,,,`,~,~,b,b,b,b,,`,,`,~,~,~ +~,~,~,b,b,b,b,,,`,~,~,~,b,b,b,,,~,~,~,b,b,b,b,,,`,~,~,~,~,~ +~,~,~,~,b,b,b,,,,~,~,~,~,~,,,,~,~,~,~,b,b,b,,,,~,~,~,~,~ +~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~ +,~,~,~,,,,`,,,,~,~,~,,,`,,,~,~,~,,,,`,,,,~,~,~ +,,`,,,,,,,,,,`,,,,,,,,`,,,,,,,,,,` +,`,,`,b,b,b,,,,,`,,`,,,,,,`,,`,b,b,b,,,,,`,,` +,,`,b,b,b,b,,,`,,,`,b,b,b,,,,,`,b,b,b,b,,,`,,,` +,,,b,b,b,b,,`,,`,,b,b,b,b,,,`,,,b,b,b,b,,`,,` +,,,b,b,b,b,,,`,,,b,b,b,b,,`,,`,,b,b,b,b,,,` +,,,,b,b,b,,,,,,b,b,b,b,,,`,,,,b,b,b +,,,,,,,,,,,,,b,b,b +#zone label(zone3) start(17; 17) hidden() +,,,,,,,,,,,,,~,~,~ +,,,,~,~,~,,,,,,~,~,~,~,~,,`,,,,~,~,~ +,,,~,~,~,~,~,,`,,,~,~,~,~,~,`,,`,,~,~,~,~,~,,` +,~,~,~,~,~,~,~,`,,`,~,~,~,~,~,~,,`,~,~,~,~,~,~,~,`,,`,~,~,~ +~,~,~,~,~,~,~,~,,`,~,~,~,~,~,~,,,~,~,~,~,~,~,~,~,,`,~,~,~,~,~ +~,~,~,~,~,~,~,,,,~,~,~,~,~,,,,~,~,~,~,~,~,~,,,,~,~,~,~,~ +~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~ +,,,,,,,`,,,,,,,,,`,,,,,,,,,` +b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b +b,b,b,b,b,~,~,,,,b,b,b,b,b,,,,b,b,b,b,b,~,~,,,,b,b,b,b,b +b,b,b,b,b,~,~,~,,`,b,b,b,b,b,~,,,b,b,b,b,b,~,~,~,,`,b,b,b,b,b +,b,b,b,~,~,~,~,`,,`,b,b,b,~,~,~,,`,b,b,b,~,~,~,~,`,,`,b,b,b +,,~,~,~,~,~,~,,`,~,~,~,~,~,~,~,`,,`,~,~,~,~,~,~,,`,~,~,~ +,~,~,~,~,~,~,,,~,~,~,~,~,~,~,~,,`,~,~,~,~,~,~,,,~,~,~,~,~ +,~,~,~,~,~,,,,~,~,~,~,~,~,~,,,,~,~,~,~,~,,,,~,~,~,~,~ +,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~ +,,,,,,,`,,,,,,,,,,,,,,,,,,` +,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b +,b,b,b,b,b,,,,b,b,b,b,b,~,~,,,,b,b,b,b,b,,,,b,b,b,b,b +,b,b,b,b,b,~,,,b,b,b,b,b,~,~,~,,`,b,b,b,b,b,~,,,b,b,b,b,b +,,b,b,b,~,~,~,,`,b,b,b,~,~,~,~,`,,`,b,b,b,~,~,~,,`,b,b,b +,~,~,~,~,~,~,~,`,,`,~,~,~,~,~,~,,`,~,~,~,~,~,~,~,`,,`,~,~,~ +~,~,~,~,~,~,~,~,,`,~,~,~,~,~,~,,,~,~,~,~,~,~,~,~,,`,~,~,~,~,~ +~,~,~,~,~,~,~,,,,~,~,~,~,~,,,,~,~,~,~,~,~,~,,,,~,~,~,~,~ +~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~ +,,,,,,,`,,,,,,,,,`,,,,,,,,,` +b,b,b,b,b,,,,,,b,b,b,b,b,,,,b,b,b,b,b,,,,,,b,b,b,b,b +b,b,b,b,b,~,~,,,,b,b,b,b,b,,,,b,b,b,b,b,~,~,,,,b,b,b,b,b +b,b,b,b,b,~,~,~,,`,b,b,b,b,b,~,,,b,b,b,b,b,~,~,~,,`,b,b,b,b,b +,b,b,b,~,~,~,~,`,,`,b,b,b,~,~,~,,`,b,b,b,~,~,~,~,`,,`,b,b,b +,,,~,~,~,~,~,,`,,,~,~,~,~,~,`,,`,,~,~,~,~,~,,` +,,,,~,~,~,,,,,,~,~,~,~,~,,`,,,,~,~,~ +,,,,,,,,,,,,,~,~,~ +#zone label(zone4) start(17; 17) hidden() +,,,,,,,,,,,,,~,~,~,,b,b,b +,,,,~,~,~,,b,b,b,,~,~,~,~,,b,b,b,b,,~,~,~,,b,b,b +,,,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b +,~,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~ +~,~,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,~,~,~,~,~,,b,b,b,b,~,~,~ +~,~,~,~,~,~,~,,b,b,b,~,~,~,~,,,,~,~,~,~,~,~,~,,b,b,b,~,~,~,~ +~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~ +,~,~,~,,,,`,,,,~,~,~,,,`,,,~,~,~,,,,`,,,,~,~,~ +~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~ +~,~,~,~,~,~,~,,b,b,b,~,~,~,~,,,,~,~,~,~,~,~,~,,b,b,b,~,~,~,~ +~,~,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,~,~,~,~,~,,b,b,b,b,~,~,~ +,~,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~ +,,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~ +,~,~,~,~,~,~,,b,b,b,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,~,~,~ +,~,~,~,~,~,,,,~,~,~,~,~,~,~,,b,b,b,~,~,~,~,,,,~,~,~,~,~ +,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~ +,,~,~,~,,,`,,,~,~,~,,,,,,,,~,~,~,,,`,,,~,~,~ +,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~ +,~,~,~,~,~,,,,~,~,~,~,~,~,~,,b,b,b,~,~,~,~,,,,~,~,~,~,~ +,~,~,~,~,~,~,,b,b,b,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,~,~,~ +,,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~ +,~,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~ +~,~,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,~,~,~,~,~,,b,b,b,b,~,~,~ +~,~,~,~,~,~,~,,b,b,b,~,~,~,~,,,,~,~,~,~,~,~,~,,b,b,b,~,~,~,~ +~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~ +,~,~,~,,,,`,,,,~,~,~,,,`,,,~,~,~,,,,`,,,,~,~,~ +~,~,~,~,~,,,,,,~,~,~,~,~,,,,~,~,~,~,~,,,,,,~,~,~,~,~ +~,~,~,~,~,~,~,,b,b,b,~,~,~,~,,,,~,~,~,~,~,~,~,,b,b,b,~,~,~,~ +~,~,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,~,~,~,~,~,,b,b,b,b,~,~,~ +,~,~,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~ +,,,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b,~,~,~,~,,b,b,b,b +,,,,~,~,~,,b,b,b,,~,~,~,~,,b,b,b,b,,~,~,~,,b,b,b +,,,,,,,,,,,,,~,~,~,,b,b,b +#build label(build) start(17; 17) hidden() + +,,,,,,,,,,,,,,f,,,,f +,,,,,h,,,,h,,,,b,,d,,d,,b,,,,h,,,,h +,,,,b,,d,,d,,b,,,,h,,,,h,,,,b,,d,,d,,b +,,b,,,f,,,,f,,,b,,,,,,,,b,,,f,,,,f,,,b +,f,,h,,,,,,,,h,,f,,,,,,f,,h,,,,,,,,h,,f +,,d,,,,,,,,,,d,,,,,,,,d,,,,,,,,,,d +,,,,,,,s,,,,,,,,,s,,,,,,,,,s +,,d,,,,,,,,,,d,,,,,,,,d,,,,,,,,,,d +,f,,h,,,,,,,,h,,f,,,,,,f,,h,,,,,,,,h,,f +,,b,,,f,,,,f,,,b,,,,,,,,b,,,f,,,,f,,,b +,,,,b,,d,,d,,b,,,,h,,,,h,,,,b,,d,,d,,b +,,,,,h,,,,h,,,,b,,d,,d,,b,,,,h,,,,h +,,,b,,,,,,,,b,,,f,,,,f,,,b,,,,,,,,b +,,h,,f,,,,,,f,,h,,,,,,,,h,,f,,,,,,f,,h +,,,d,,,,,,,,d,,,,,,,,,,d,,,,,,,,d +,,,,,,,s,,,,,,,,,,,,,,,,,,s +,,,d,,,,,,,,d,,,,,,,,,,d,,,,,,,,d +,,h,,f,,,,,,f,,h,,,,,,,,h,,f,,,,,,f,,h +,,,b,,,,,,,,b,,,f,,,,f,,,b,,,,,,,,b +,,,,,h,,,,h,,,,b,,d,,d,,b,,,,h,,,,h +,,,,b,,d,,d,,b,,,,h,,,,h,,,,b,,d,,d,,b +,,b,,,f,,,,f,,,b,,,,,,,,b,,,f,,,,f,,,b +,f,,h,,,,,,,,h,,f,,,,,,f,,h,,,,,,,,h,,f +,,d,,,,,,,,,,d,,,,,,,,d,,,,,,,,,,d +,,,,,,,s,,,,,,,,,s,,,,,,,,,s +,,d,,,,,,,,,,d,,,,,,,,d,,,,,,,,,,d +,f,,h,,,,,,,,h,,f,,,,,,f,,h,,,,,,,,h,,f +,,b,,,f,,,,f,,,b,,,,,,,,b,,,f,,,,f,,,b +,,,,b,,d,,d,,b,,,,h,,,,h,,,,b,,d,,d,,b +,,,,,h,,,,h,,,,b,,d,,d,,b,,,,h,,,,h +,,,,,,,,,,,,,,f,,,,f diff --git a/data/blueprints/bedrooms/95-9-Hactar1_3_Branch_Tree.csv b/data/blueprints/bedrooms/95-9-Hactar1_3_Branch_Tree.csv new file mode 100644 index 0000000000..78543b1e04 --- /dev/null +++ b/data/blueprints/bedrooms/95-9-Hactar1_3_Branch_Tree.csv @@ -0,0 +1,228 @@ +"#dig label(dig) start(36;73) 95 bedrooms (including 14 suites), 190 tombs" + +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,,d,,,d,,,d,,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,,d,,,d,,,d,,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,,d,,,,,,,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,,d,d,d,d,,d,,d,d,d,d,,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,d,d,d,d,d,d,d,,d,,d,d,d,d,d,d,d,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,,d,d,d,d,,d,,d,d,d,d,,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,d,d,d,,,d,,,,,,,d,,,,,,,d,,,,,,,d,,,,,,,d,,,d,d,d +,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,d,d,d,,,d,,,,,,,d,,,,,,d,d,d,,,,,,d,,,,,,,d,,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,d,d,d,d,d,d,,d,d,d,,d,d,d,d,d,d,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,d,d,d,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,d,,d,d,d,,d,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,d,d,d,d,d,d,d,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,d,,d,d,d,,d,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,,d,,,d,d,d,,,d,,,,,,,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,,d,,,d,d,d,,,d,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,d,d,d,,d,d,d,,d,d,d,,,,,,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,,,,,d,d,d,,,,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,d,d,d,,d,d,d,,,d,,,d,,,d,,,d,d,d,,d,d,d,,d,d,d,,,d,,,d,,,d,,,d,d,d,,d,d,d +,,,,,,,,,,,,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,d,d,d +,,,,,,,,,,,,d,d,d,,d,d,d,,,d,,,d,,,d,,,d,d,d,,d,d,d,,d,d,d,,,d,,,d,,,d,,,d,d,d,,d,d,d +,,,,,,,,,,,,,d,,,,,,,d,d,d,,d,,d,d,d,,,,,,d,d,d,,,,,,d,d,d,,d,,d,d,d,,,,,,,d +,,,,,d,d,d,,d,d,d,,d,,d,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,d,,d,,d,d,d,,d,d,d +,,,,,d,d,d,,d,d,d,d,d,d,d,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,d,d,d,d,d,d,d,,d,d,d +,,,,,d,d,d,,d,d,d,,d,,d,d,d,d,,d,d,d,,d,,,,,,,d,,,d,d,d,,,d,,,,,,,d,,d,d,d,,d,d,d,d,,d,,d,d,d,,d,d,d +,d,d,d,,,d,,,,,,,d,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,,d,,,,,,,d,,,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,,,d,,,,,,,d,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,,d,,,,,,,d,,,d,d,d +,,,,,d,d,d,,d,d,d,,d,,d,d,d,d,,d,d,d,,d,,,,,,,d,,,d,d,d,,,d,,,,,,,d,,d,d,d,,d,d,d,d,,d,,d,d,d,,d,d,d +,,,,,d,d,d,,d,d,d,d,d,d,d,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,d,d,d,d,d,d,d,,d,d,d +,,,,,d,d,d,,d,d,d,,d,,d,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d,,d,d,d,d,,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,d,,,,,,,d,d,d,,d,,d,d,d,,,,,,d,d,d,,,,,,d,d,d,,d,,d,d,d,,,,,,,d +,,,,,,,,,,,,d,d,d,,d,d,d,,,d,,,d,,,d,,,d,d,d,,d,d,d,,d,d,d,,,d,,,d,,,d,,,d,d,d,,d,d,d +,,,,,,,,,,,,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,d,d,d +,,,,,,,,,,,,d,d,d,,d,d,d,,,d,,,d,,,d,,,d,d,d,,d,d,d,,d,d,d,,,d,,,d,,,d,,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,,,,,d,d,d,,,,,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,d,d,d,d,d,d,d,d,d,d,d,,,,,,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,,,d,,,d,d,d,,,d,,,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,,,,,d,d,d,,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,,d,d,,d,d,d,,d,d,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,d,,d,d,d,,d,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,d,d,d,,d,d,d,,d,d,d,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,d,d,d,,d,d,d,,d,d,,d,d,d,,d,d,,d,d,d,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,d,d +,,,,,,,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,~,~,~,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,~,~,~,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,~,~,~,d,d,d,d,d,d,d,d,d,d,d,d +#meta label(rooms) +zone/zone +build/build +#zone label(zone) start(36;73) hidden() +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,b(5x5) +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,b(5x5),,,,,`,b(5x5) +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,b(5x5),,,,,`,b(5x5) +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,`,,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,`,,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5) +,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),,,`,,,`,,,`,,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),b(5x6),,`,,,`,b(5x6),,`,,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5) +,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,`,,`,,`,`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,`,,`,,`,`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,`,,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,,,,,,,,,,,,,,,,b(5x5),,,,b(5x5),,,,,`,b(6x5),,,,,,`,b(6x5),,,,,,`,b(5x5),,,,b(5x5) +,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,`,,`,,`,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,,`,`,` +,,,,,,,,,,,,,,,b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,`,,`,,`,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5) +,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),,,`,,,,,,,`,,,,,,,`,,,,,,,`,,,,,,,`,,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),b(5x5),,`,,b(5x5),,,,,`,b(5x5),,,,,`,`,`,b(5x5),,,,,`,b(5x5),,,,b(5x5),,`,,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,`,`,`,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,`,`,`,`,`,`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,`,`,`,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,b(5x5),,,,b(5x5),,`,,b(4x5),,,,`,`,`,b(4x5),,,b(5x5),,`,,b(5x5) +,,,,,,,,,,,,,,,,,,,,,,,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,`,,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,`,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),`,,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,,,,,,,,,,,,,,,,b(5x5),,,,,`,b(5x5),,,,b(5x4),,`,,,`,`,`,b(5x4),,`,,b(5x5),,,,,`,b(5x5) +,,,,,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,b(5x5),,`,,,`,`,`,b(5x5),,`,,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,b(5x5),,,,,`,b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5),,,,,`,b(5x5) +,,,,,,,,,,,,,,,,,,,,`,`,`,,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,`,`,`,,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,,`,`,` +,,,,,,,,,,,b(5x5),,,,b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5),,,,,`,`,`,b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5),,,,b(5x5) +,,,,,,,,,,,,`,`,`,,`,`,T{pets=true}(1x1),,,`,,,`,,,`,,,T{pets=true}(1x1),`,`,,`,`,`,,`,`,T{pets=true}(1x1),,,`,,,`,,,`,,,T{pets=true}(1x1),`,`,,`,`,` +,,,,,,,,,,,,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,` +,,,,,,,,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),b(5x6),,`,,,`,b(5x5),,`,,,T{pets=true}(1x1),`,`,,`,`,`,,`,`,T{pets=true}(1x1),b(5x5),,`,,,`,b(5x6),,`,,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,b(5x5),,,,b(5x5),,,,,`,b(6x5),,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x4),,,,,`,`,`,b(5x4),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(6x5),,,,,,`,b(5x5),,,,b(5x5) +,,,,,`,`,`,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,`,,`,`,`,,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,,`,`,`,,`,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,`,`,` +,,,,,`,`,`,,`,`,`,`,`,`,`,`,`,`,,`,`,`,,`,,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,`,,`,`,`,,`,`,`,`,`,`,`,`,`,`,,`,`,` +b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,`,,`,`,`,,`,,,,,,,`,,,`,`,`,,,`,,,,,,,`,,`,`,`,,`,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5) +,`,`,T{pets=true}(1x1),,,`,,,,,,,`,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,`,,,,,,,`,,,T{pets=true}(1x1),`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,T{pets=true}(1x1),b(5x5),,`,,b(5x5),,,,,`,b(6x5),,,,,b(5x6),,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,b(5x6),,,,b(6x5),,,,,,`,b(5x5),,,,b(5x5),,`,,,T{pets=true}(1x1),`,` +,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,`,,`,`,`,,`,b(5x5),,,,b(5x4),,`,,,`,`,`,b(5x4),,`,,b(5x5),,,,,`,,`,`,`,,`,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,,`,`,`,,`,`,`,`,`,`,`,`,`,`,,`,`,`,,`,,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,`,,`,`,`,,`,`,`,`,`,`,`,`,`,`,,`,`,` +,,,,,`,`,`,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,`,,`,`,`,,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,,`,`,`,,`,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,`,`,` +,,,,,,,,,,,b(5x5),,`,,b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5),,,,,`,`,`,b(5x5),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x5),,,,b(5x5),,` +,,,,,,,,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),,,`,,,`,,,`,,,T{pets=true}(1x1),`,`,,`,`,`,,`,`,T{pets=true}(1x1),,,`,,,`,,,`,,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,` +,,,,,,,,,,,,`,`,`,,`,`,T{pets=true}(1x1),b(5x5),,`,,,`,b(5x5),,`,,,T{pets=true}(1x1),`,`,,`,`,`,,`,`,T{pets=true}(1x1),b(5x5),,`,,,`,b(5x5),,`,,,T{pets=true}(1x1),`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),b(5x6),,,,,`,`,`,b(5x6),,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,,,,,,,,,,,,,,,,,`,`,`,,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,`,`,`,,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,,`,`,` +,,,,,,,,,,,,,,,,,,,b(5x5),,,,,`,b(5x5),,,,,`,`,`,`,`,`,`,`,`,`,`,b(5x5),,,,,`,b(5x5) +,,,,,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,,,`,,,`,`,`,,,`,,,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,T{pets=true}(1x1),,`,,T{pets=true}(1x1),`,` +,,,,,,,,,,,,,,,,,,,,,,b(5x5),,`,,b(5x5),,,,,`,`,,`,`,`,,`,`,b(5x5),,,,b(5x5),,` +,,,,,,,,,,,,,,,,,,,,,,,T{pets=true}(1x1),`,T{pets=true}(1x1),,`,`,T{pets=true}(1x1),,`,`,,`,`,`,,`,`,,T{pets=true}(1x1),`,`,,T{pets=true}(1x1),`,T{pets=true}(1x1) +,,,,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,`,`,`,`,,`,`,`,,`,`,`,`,`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,`,`,`,,`,`,T{pets=true}(1x1),,`,`,,`,`,`,,`,`,,T{pets=true}(1x1),`,`,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` +#build label(build) start(36;73) hidden() + +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,h,`,f +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,b,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,n,`,n +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,f,`,n,,`,,n,`,f +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,b,`,d,`,d,`,b,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,h,`,n,,`,,n,`,h +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,h,`,f,,`,,h,`,f +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,b,`,,`,,`,b,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,n,`,n,,`,,n,`,n +,,,,,,,,,,,,,,,,,,,,,,,,,,,f,`,n,,,d,,,`,,,d,,,n,`,f +,,,,,,,,,,,,,,,,,,,,,,,,,,,`,b,`,d,`,`,`,`,`,`,`,`,`,d,`,b,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,h,`,n,,,d,,,`,,,d,,,n,`,h +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,n,`,n,,`,,n,`,n +,,,,,,,,,,,,,,,,,,,,,,,,,,,h,`,f,,r,b,t,,`,,r,b,t,,h,`,f +,,,,,,,,,,,,,,,,,,,,,,,,,,,`,b,`,,a,`,c,,`,,a,`,c,,`,b,` +,,,,,,,,,,,,,,,,,,,,,,,,,,,n,`,n,,h,s,f,,`,,h,s,f,,n,`,n +,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,,`,,,,,,,d +,,,,,,,,,,,,,,,,,,,,h,`,f,,f,`,n,,`,,n,r,a,h,,`,,h,a,r,n,,`,,n,`,f,,h,`,f +,,,,,,,,,,,,,,,,,,,,`,b,`,,`,b,`,d,`,d,`,b,`,s,,`,,s,`,b,`,d,`,d,`,b,`,,`,b,` +,,,,,,,,,,,,,,,,,,,,n,`,n,,h,`,n,,`,,n,t,c,f,,`,,f,c,t,n,,`,,n,`,h,,n,`,n +,,,,,,,,,,,,,,,,f,`,n,,,d,,,,,,,`,,,,,,,`,,,,,,,`,,,,,,,d,,,n,`,f +,,,,,,,,,,,,,,,,`,b,`,d,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,d,`,b,` +,,,,,,,,,,,,,,,,h,`,n,,,d,,,,,,,`,,,,,,`,`,`,,,,,,`,,,,,,,d,,,n,`,h +,,,,,,,,,,,,,,,,,,,,n,`,n,,f,`,n,,`,,n,`,f,,`,`,`,,f,`,n,,`,,n,`,f,,n,`,n +,,,,,,,,,,,,,,,,,,,,`,b,`,,`,b,`,d,`,d,`,b,`,,`,`,`,,`,b,`,d,`,d,`,b,`,,`,b,` +,,,,,,,,,,,,,,,,,,,,h,`,f,,h,`,n,,`,,n,`,h,,`,`,`,,h,`,n,,`,,n,`,h,,h,`,f +,,,,,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,`,`,`,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,h,`,f,,n,`,n,,f,n,,`,`,`,,n,f,,n,`,n,,h,`,f +,,,,,,,,,,,,,,,,,,,,,,,`,b,`,,`,b,`,,b,`,d,`,`,`,d,`,b,,`,b,`,,`,b,` +,,,,,,,,,,,,,,,,,,,,,,,n,`,n,,h,`,f,,h,n,,`,`,`,,n,h,,h,`,f,,n,`,n +,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,,d,,,`,`,`,,,d,,,,,,,d +,,,,,,,,,,,,,,,,,,,,f,`,n,,`,,n,`,f,,n,`,n,,`,`,`,,n,`,n,,f,`,n,,`,,n,`,f +,,,,,,,,,,,,,,,,,,,,`,b,`,d,`,d,`,b,`,,h,b,f,,`,`,`,,h,b,f,,`,b,`,d,`,d,`,b,` +,,,,,,,,,,,,,,,,,,,,h,`,n,,`,,n,`,h,,,d,,,`,`,`,,,d,,,h,`,n,,`,,n,`,h +,,,,,,,,,,,,,,,,,,,,,,,,`,,,,,,n,`,n,,`,`,`,,n,`,n,,,,,,` +,,,,,,,,,,,,,,,,,,,,h,`,f,,`,,h,`,f,,`,b,`,,`,`,`,,`,b,`,,h,`,f,,`,,h,`,f +,,,,,,,,,,,,,,,,,,,,`,b,`,,`,,`,b,`,,h,`,f,,`,`,`,,h,`,f,,`,b,`,,`,,`,b,` +,,,,,,,,,,,,,,,,,,,,n,`,n,,`,,n,`,n,,,,,,`,`,`,,,,,,n,`,n,,`,,n,`,n +,,,,,,,,,,,,h,`,f,,f,`,n,,,d,,,`,,,d,,,n,`,f,,`,`,`,,f,`,n,,,d,,,`,,,d,,,n,`,f,,h,`,f +,,,,,,,,,,,,`,b,`,,`,b,`,d,`,`,`,`,`,`,`,`,`,d,`,b,`,,`,`,`,,`,b,`,d,`,`,`,`,`,`,`,`,`,d,`,b,`,,`,b,` +,,,,,,,,,,,,n,`,n,,h,`,n,,,d,,,`,,,d,,,n,`,h,,`,`,`,,h,`,n,,,d,,,`,,,d,,,n,`,h,,n,`,n +,,,,,,,,,,,,,d,,,,,,,n,`,n,,`,,n,`,n,,,,,,`,`,`,,,,,,n,`,n,,`,,n,`,n,,,,,,,d +,,,,,h,`,f,,f,`,n,,`,,n,r,a,h,,r,b,t,,`,,`,b,`,,h,b,f,,`,`,`,,h,b,f,,`,b,`,,`,,r,b,t,,h,a,r,n,,`,,n,`,f,,h,`,f +,,,,,`,b,`,,`,b,`,d,`,d,`,b,`,s,,a,`,c,,`,,h,`,f,,n,`,n,,`,`,`,,n,`,n,,h,`,f,,`,,a,`,c,,s,`,b,`,d,`,d,`,b,`,,`,b,` +,,,,,n,`,n,,h,`,n,,`,,n,t,c,f,,h,s,f,,`,,,,,,,d,,,`,`,`,,,d,,,,,,,`,,h,s,f,,f,c,t,n,,`,,n,`,h,,n,`,n +,f,`,n,,,d,,,,,,,`,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,`,,,,,,,d,,,n,`,f +,`,b,`,d,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,d,`,b,` +,h,`,n,,,d,,,,,,,`,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,`,,,,,,,d,,,n,`,h +,,,,,n,`,n,,f,`,n,,`,,n,r,a,h,,h,s,f,,`,,,,,,,d,,,`,`,`,,,d,,,,,,,`,,h,s,f,,h,a,r,n,,`,,n,`,f,,n,`,n +,,,,,`,b,`,,`,b,`,d,`,d,`,b,`,s,,a,`,c,,`,,h,`,f,,n,`,n,,`,`,`,,n,`,n,,h,`,f,,`,,a,`,c,,s,`,b,`,d,`,d,`,b,`,,`,b,` +,,,,,h,`,f,,h,`,n,,`,,n,t,c,f,,r,b,t,,`,,`,b,`,,h,b,f,,`,`,`,,h,b,f,,`,b,`,,`,,r,b,t,,f,c,t,n,,`,,n,`,h,,h,`,f +,,,,,,,,,,,,,d,,,,,,,n,`,n,,`,,n,`,n,,,,,,`,`,`,,,,,,n,`,n,,`,,n,`,n,,,,,,,d +,,,,,,,,,,,,n,`,n,,f,`,n,,,d,,,`,,,d,,,n,`,f,,`,`,`,,f,`,n,,,d,,,`,,,d,,,n,`,f,,n,`,n +,,,,,,,,,,,,`,b,`,,`,b,`,d,`,`,`,`,`,`,`,`,`,d,`,b,`,,`,`,`,,`,b,`,d,`,`,`,`,`,`,`,`,`,d,`,b,`,,`,b,` +,,,,,,,,,,,,h,`,f,,h,`,n,,,d,,,`,,,d,,,n,`,h,,`,`,`,,h,`,n,,,d,,,`,,,d,,,n,`,h,,h,`,f +,,,,,,,,,,,,,,,,,,,,n,`,n,,`,,n,`,n,,,,,,`,`,`,,,,,,n,`,n,,`,,n,`,n +,,,,,,,,,,,,,,,,,,,,`,b,`,,`,,`,b,`,,h,s,f,,`,`,`,,h,s,f,,`,b,`,,`,,`,b,` +,,,,,,,,,,,,,,,,,,,,h,`,f,,`,,h,`,f,,a,`,c,,`,`,`,,a,`,c,,h,`,f,,`,,h,`,f +,,,,,,,,,,,,,,,,,,,,,,,,`,,,,,,r,b,t,d,`,`,`,d,r,b,t,,,,,,` +,,,,,,,,,,,,,,,,,,,,f,`,n,,`,,n,`,f,,n,`,n,,`,`,`,,n,`,n,,f,`,n,,`,,n,`,f +,,,,,,,,,,,,,,,,,,,,`,b,`,d,`,d,`,b,`,,,d,,,`,`,`,,,d,,,`,b,`,d,`,d,`,b,` +,,,,,,,,,,,,,,,,,,,,h,`,n,,`,,n,`,h,,`,`,`,,`,`,`,,`,`,`,,h,`,n,,`,,n,`,h +,,,,,,,,,,,,,,,,,,,,,,,,d,,,,,,,`,`,,`,`,`,,`,`,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,n,`,n,,f,`,n,,`,`,,`,`,`,,`,`,,n,`,f,,n,`,n +,,,,,,,,,,,,,,,,,,,,,,,`,b,`,,`,b,`,d,`,`,,`,`,`,,`,`,d,`,b,`,,`,b,` +,,,,,,,,,,,,,,,,,,,,,,,h,`,f,,h,`,n,,`,`,,`,`,`,,`,`,,n,`,h,,h,`,f +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` diff --git a/data/blueprints/dreamfort.csv b/data/blueprints/dreamfort.csv new file mode 100644 index 0000000000..c1266edb6e --- /dev/null +++ b/data/blueprints/dreamfort.csv @@ -0,0 +1,3238 @@ +#notes label(help) run me for the dreamfort walkthrough +"Welcome to Dreamfort! These blueprints will help you build a functional, secure, fully self-sustaining fortress that you can use as-is or extend to build the fortress of your dreams!" +"" +"It can be difficult to apply a set of blueprints that you did not write yourself. This walkthrough will guide you through the high-level steps of building Dreamfort. Run ""gui/quickfort dreamfort /checklist"" (or, if you're looking at the online version, switch to the ""checklist"" sheet) for a compact list of the blueprints you'll be applying. Each level also has its own mini-walkthrough with more details." +"" +"The final fort will have a walled-in area on the surface for livestock, trading, aboveground farming, and military training. One z-level down is the farming level, with related workshops and vents up to the surface for miasma prevention. The farming level also has a miniature dining hall and dormitory for use until you get the services and housing levels set up." +"" +"Beyond those two, the other layers can be built in any order, at any z-level, according to your preference and the layout peculiarities of your embark site:" +"- The industry level has a compact, but complete set of workshops and stockpiles (minus what is already provided on the farming level)." +"- The services level has dining, hospital, marksman barracks, and justice services. It has a well system and is 4 z-levels deep." +"- The guildhall level has large rooms for building libraries, temples, and guildhalls, with optional furniture layouts." +- The suites level has fancy rooms for your nobles with the furniture that they require. +- The apartments levels have small but well-furnished bedrooms for your other dwarves. +- The crypt level houses your dead. +"" +"Run each level's ""help"" blueprint (e.g. ""gui/quickfort dreamfort /surface_help"") for more details." +"" +"Dreamfort has a central stairs-based design. For all Dreamfort levels, place the cursor on the center (undug) tile of the 3x3 stairs area when you apply the blueprints for that level. The first surface blueprint will designate a column of stairs that you can use as a guide. If you need to extend the stairs down further to lower levels, run ""gui/quickfort dreamfort /central_stairs"" and set the repeat option to go down however many levels you need (each repetition is 2 levels). Apply it with the cursor on the z-level below the lowest current stairs." +"" +"Dreamfort blueprints take care of everything to get the fort up and running. You don't need to clear any extra trees or create any extra buildings or stockpiles (though of course you are free to do so). Blueprints that do require manual steps, like 'assign minecart to hauling route', will leave a message telling you so when you run them. Note that blueprints will designate buildings to build even if you don't have the materials needed to build them. You can use the ""o"" hotkey to automatically create the manager orders for all the needed items when you have a blueprint loaded in gui/quickfort. Make sure your manager is available to validate all the incoming work orders!" +"" +"There are some tasks common to all forts that Dreamfort doesn't specifically handle for you. For example, Dreamfort sets up a barracks, but managing squads is up to you. Here are some other common tasks that may need to be done manually (or with some other tool):" +- Exploratory mining for specific resources like iron (see gui/design for help with this) +"- Filling the well system with water (if you have a light aquifer, see library/aquifer_tap.csv for help with this)" +- Bringing magma up to the industry level to power magma forges/furnaces (see library/pump_stack.csv for help with this) +- Manufacturing trade goods +"- Custom stockpile setups to assist with, for example, encrusting only high-quality items" +"" +"Dreamfort works best at an embark site that is relatively flat and has at least one soil layer. New players should avoid embarks with aquifers if they are not prepared to deal with them. Bring picks for mining, an axe for woodcutting, and an anvil for a forge. Bring a few blocks to speed up initial workshop construction as well. That's all you really need, but see the example embark profile in the online spreadsheets for a more complete setup." +"" +"Other DFHack tools also work very well with Dreamfort, such as autofarm. See the /setup_help blueprint for a suggested list to turn on in the DFHack gui/control-panel." +"" +"Once you have your starting surface workshops up and running, you might want to configure buildingplan to only use blocks for constructions so it won't use your precious wood, boulders, and bars to build floors and walls. If you bring at least 7 blocks with you on embark, you can set this to be your default in the Automation -> Autostart tab of gui/control-panel." +"" +"Directly after embark, run ""gui/quickfort dreamfort /setup_help"" to get some advice on initial settings, and get started building your fort with ""gui/quickfort dreamfort /surface1"" on the surface (see /surface_help for how to select a good spot). Read the walkthroughs for each level to understand what's going on and follow the checklist to keep track of where you are in the building process. Good luck, and have fun building an awesome Dreamfort-based fort!" +"" +"The dreamfort.csv file distributed with DFHack is generated from online spreadsheet files. If you want to look at how these blueprints are put together, it is easier to look at the online spreadsheets than the giant .csv. You can view them at: https://drive.google.com/drive/folders/1dsmvnzbOKsyFS3DCj0F8ibSnMhVHEjdV" +You are welcome to copy the Dreamfort spreadsheets and make your own modifications! +"" +"If you like, you can download a fully built Dreamfort-based fort from https://dffd.bay12games.com/file.php?id=15434 and explore it +interactively." +"# The dreamfort.csv distributed with DFHack is generated from the online spreadsheets with the following command: + for fname in dreamfort*.xlsx; do xlsx2csv -a -p '' ""$fname""; done | sed 's/,*$//'" +#notes label(checklist) command checklist +"Here is the recommended order for Dreamfort commands. Each line is a blueprint that you run with gui/quickfort (default keybinding: Ctrl-Shift-Q), except where we use other tools as noted. If you set ""dreamfort"" as the filter when you open gui/quickfort, you'll conveniently only see Dreamfort blueprints to choose from. See the walkthroughs (the ""help"" blueprints) for context and details. You can also copy text from this spreadsheet when viewing it online and paste it into gui/launcher with Ctrl-V." +"If the checklist indicates that you should generate orders, that means to hit the ""o"" hotkey when the blueprint is loaded in gui/quickfort. You'll get a popup saying which orders were generated. Also remember to read the messages the blueprints display after you run them so you don't miss any important manual steps!" +"" +-- Preparation (before you embark!) -- +Optionally copy the premade Dreamfort embark profile from the online spreadsheets to the prefs/embark_profiles.txt file. +Run gui/control-panel and enable settings on the Autostart tabs. See the /setup_help notes for details. +"" +-- Set settings and preload initial orders -- +DFHack command,Blueprint,Generate orders,Notes +gui/quickfort,/setup_help,,For advice on how to do initial setup for success. +"quickfort orders library/dreamfort.csv -n ""/surface2, /farming2, /surface3, /industry2, /surface4, /industry3""",,,"Queue up orders required to get the fort minimally functional and secure. You can remove the order for the anvil (you brought one with you, right?)." +"" +-- Find a good starting spot on the surface -- +DFHack command,Blueprint,Generate orders,Notes +gui/quickfort,/perimeter,,Run at embark. Don't actually apply the blueprint -- it's way too early to dedicate resources to building walls. Just use the preview shadow to find a good spot on the surface. See the surface level help for how to find a good spot. +"" +-- Dig -- +DFHack command,Blueprint,Generate orders,Notes +gui/quickfort,/surface1,,Clear some trees and dig central staircase. Run when you find your center tile. Deconstruct your wagon if it is in the way. +gui/quickfort,/dig_all,,"Run when you find a suitable (non-aquifer) rock layer for the industry level. It designates digging for industry, services, guildhall, suites, apartments, and the crypt all in one go. This list does not include the farming level, which we'll designate in the uppermost soil layer once the surface miasma channels are dug. Note that it is more efficient for your miners if you designate the digging for a level before they dig the central stairs past that level. The stairs down on each level are designated at priority 5 instead of the regular priority 4. This lets the miners focus on one z-level at a time and not run up and down the stairs attempting to dig out two blueprints simultaneously. If you need to designate your levels individually due to caverns interrupting the sequence or just because it is your preference, run the level-specific dig blueprints (i.e. /industry1, /services1, /guildhall1, /suites1, 3 levels of /apartments1, and /crypt1) instead of running /dig_all." +"" +-- Core fort (should finish at about the third migration wave) -- +DFHack command,Blueprint,Generate orders,Notes +gui/quickfort,/surface2,,"Build starter workshops/stockpiles and dig miasma vents. Run after initial trees are cleared. If you are deconstructing the wagon, do it before running this blueprint so the jobs that depend on scattered wagon contents (e.g. blocks) don't get canceled later." +gui/quickfort,/farming1,,Dig out the farming level. Run when channels on the surface are dug and the additional designated trees are cleared. +gui/quickfort,/farming2,,Build farming level. Run as soon as the farming level has been completely dug out. +gui/quickfort,/surface3,,Cover the miasma vents and start protecting the central staircase from early invasions. Run when /farming2 is mostly complete. +gui/quickfort,/industry2,,"Build industry level. Run as soon as the industry level has been completely dug out. As industry workshops are built, you can remove the temporary workshops and stockpiles on the surface. Be sure that there are no items attached to jobs left in the surface workshops before deconstructing them, otherwise you'll get canceled jobs!" +gui/quickfort,/surface4,,Finish protecting the staircase and lay flooring for future buildings. Run after the walls and floors around the staircase are built and you have moved production from the surface to the industry level. +gui/quickfort,/industry3,,Build the rest of the industry level. Run once /surface4 is mostly complete. +orders import library/basic,,,"Run after the first migration wave, so you have dwarves to do all the basic tasks. Note that this is the ""orders"" plugin, not the ""quickfort orders"" command." +gui/quickfort,/services2,Yes,"Build simple hospital and dining room, including a well. Run once the 4 services levels have been dug out and you have built up some stone in your industry stone stockpiles. Feel free to remove the orders for the ropes if you brought some with you. If you are filling your wells from an aquifer or stream, now is also a good time to start digging the plumbing." +gui/quickfort,/surface5,Yes,"Build surface buildings, drawbridges, and furniture. Run when all marked trees on the surface are chopped down and previously-designated walls and floors have been constructed. Be sure to check that the little ""wing"" of roof section over the future barracks is constructed so we can place the barracks beds." +gui/quickfort,/surface6,Yes,Build security perimeter. Run once you have linked all levers to their respective bridges. +gui/quickfort,/surface7,Yes,Build roof. Run after the surface walls are completed and any marked trees are chopped down. Be sure to give your haulers some time to fill the stonecutter's stockpile with some stone first so your stonecutters won't be hauling it up from the depths by hand. +"" +-- Plumbing -- +"If you haven't done it already, this is a good time to fill your well cisterns, either with a bucket brigade or by routing water from a freshwater stream or an aquifer (see the aquifer_tap library blueprint for help with this)." +Also consider bringing magma up to your services level so you can replace the forge and furnaces on your industry level with more powerful magma versions. This is especially important if your embark has insufficient trees to convert into charcoal. Keep in mind that moving magma is a tricky process and can take a long time. Don't forget to continue making progress on the rest of the fort! +"" +-- Mature fort (fourth migration wave onward) -- +"The order of steps in this section is not important. Feel free to reorder as per the needs of your fort. Once you have about 50 dwarves, you can queue up as much as you want and your haulers will be able to keep your stonecutters supplied. You can even build another two Stonecutter's workshops to speed things along. You might need to dig a quarry on an unused level to get enough stone, though." +DFHack command,Blueprint,Generate orders,Notes +orders import library/furnace,,,Automated production of basic furnace-related items. Don't forget to create a sand collection zone (or remove the sand- and glass-related orders if you have no sand). +gui/quickfort,/guildhall2_default,Yes,"Build library and non-denominational temple, and prepare space for future temples and guildhalls. Run when the guildhall level has been dug out." +gui/quickfort,/services3,Yes,"Extend the dining room and hospital, and start the jail. Run when your population grows to about 20." +gui/quickfort,/apartments2,Yes,Build and zone bedrooms. Run when the first apartment level has been dug out and you have outgrown your starter dormintory. +gui/quickfort,/suites2_default,Yes,Build rooms that you can zone for your nobles. Run when the suites level has been dug out and you are approaching a population of 50. +gui/quickfort,/crypt2,Yes,Build a small group of tombs. Run when the crypt level has been dug out and you have outgrown your starter tomb on the farming level. +gui/quickfort,/surface8,Yes,"Build extended trap corridors. If you have a strong military, you might not need this." +gui/quickfort,/farming3,Yes,Add in all the doors we couldn't afford to build earlier. +orders import library/military,,,Automated production of military equipment. Turn on automelt in the meltables piles on the industry level to automatically upgrade all metal military equipment to masterwork quality. These orders are optional if you are not using a military. +orders import library/smelting,,,Automated production of all types of metal bars. +gui/quickfort,/services4,Yes,Build full dining room and jail. +orders import library/rockstock,,,Maintains a small stock of all types of rock furniture. Useful for filling out future guildhalls. +orders import library/glassstock,,,Maintains a small stock of all types of glass furniture and parts (only import if you have sand). +gui/quickfort,/apartments2,Yes,Repeat as needed as your fort grows. +gui/quickfort,/crypt3,Yes,Run when the crypt is starting to run out of free tombs. +"" +See this checklist online at https://docs.google.com/spreadsheets/d/13PVZ2h3Mm3x_G1OXQvwKd7oIR2lK4A1Ahf6Om1kFigw/edit#gid=1459509569 +#notes label(setup_help) pre- and post-embark tasks +These are Dreamfort's suggestions for adjustments to settings and initial setup. +"" +You can save some time by setting up your settings in gui/control-panel before you embark. +"Beyond the bugfix tools that are enabled by default, we recommend enabling the following DFHack tools in gui/control-panel (but they are not required if you prefer to do these things manually):" +"" +"On the gui/control-panel ""Autostart"" tabs, enable:" +"""Automation"":" +- autobutcher +- autobutcher target 10 10 14 2 BIRD_GOOSE +- autochop +- autocheese +- autofarm +- autofarm threshold 150 grass_tail_pig +- autofish +- automilk +- autonestbox +- autoshear +- autoslab +- ban-cooking all +- buildingplan set boulders false +- buildingplan set logs false +- cleanowned +- logistics enable autoretrain +- nestboxes +- orders-sort +- prioritize +- seedwatch +- suspendmanager +- tailor +"""Gameplay"" subtab:" +- combine +- dwarfvet +- immortal-cravings +- timestream +- work-now +"Note that if you've already started your fort and have missed the ""new fort"" trigger, you can enable these tools on the ""Enabled"" tabs instead. You can run the one-time commands (like ban-cooking all) manually from gui/launcher." +"" +"Now, after you've arrived at your embark site, open the nobles screen and:" +"- Assign dwarves to at least manager, chief medical dwarf, broker, and bookkeeper noble roles (they can all be the same dwarf)" +"" +On the work details screen (Labor -> Work details) + - Specialize your miners (click the hammer-lock button so it turns red) and make your miners also engravers (they'll need something to do once the mining is done) + - Deselect fishing from all dwarves -- you have enough food to get started and you'll need their time for hauling +"" +In standing orders (Labor -> Standing orders): +" - Change ""Automatically weave all thread"" to ""No automatic weaving"" so the hospital always has thread -- we'll be managing cloth production with automated orders" +"- On the ""Other"" tab, change ""Everybody harvests"" to ""Only farmers harvest"". This will prevent unilts that don't have the Planting labor enabled from harvesting plants, allowing planting skill gains to be concentrated into your designated planters and improving your overall crop yield." +"" +"Once you have your standing orders set the way you like, you can export them and instruct DFHack to autoload your saved settings on new embarks. The controls for getting this set up are available by default in a panel at the bottom of the Standing orders -> Automated workshops tab." +"#meta label(dig_all) start(central stairs on industry level) message(You can repeat the /central_stairs blueprint down more levels if you need more stairs.) dig industry, services, guildhall, suites, apartments, and crypt levels. does not include farming." +# Note that this blueprint will only work for the unified dreamfort.csv. It won't work if you have downloaded the individual .xlsx files since #meta blueprints can't cross file boundaries. +"" +/industry1 +#> +/services1 +#>4 +/guildhall1 +#> +/suites1 +#> +/apartments1 repeat(down 3) +#>3 +/crypt1 +#ignore +"Here are the most important skills for getting Dreamfort up and running, along with suggestions for how to distribute them." +"" +Hauler / Manager / Bookkeeper / Broker,Miner,Miner,Stoneworker,Craftsdwarf,Outdoorsdwarf,Farmer +Noble role skills,Miner,Miner,Stonecutter,Stonecrafting,Carpenter,Planter +,,,Stone Carver,Mechanic,Wood Cutter,Stonecutter +"" +"The most time-consuming tasks in early Dreamfort are: mining, chopping down trees, and making blocks. Starting with at least two miners, two woodcutters (assuming your embark has trees), and two stonecutters helps keep the fort from stalling." +"" +We suggest bringing at least: +2 picks,for the two miners +2 battleaxes,for one woodcutters and either a second woodcutter or an emergency weapon +1 anvil,for the forge +food and seeds,as per usual +3 ropes,"for the hospital well and traction benches. you could make the ropes out of raw materials, but dwarves are usually too busy to do textile work at the start of the game." +20 blocks,"for starting workshops, the temporary trade depot, and a few spares in case you need to shore up a light aquifer in a soil layer. necessary if you have buildingplan configured for blocks only." +many boulders,for quickly turning into more blocks while your miners are digging in dirt or dealing with aquifers. blocks are the limiting factor in the early stages. +dogs and cats,for protection and vermin control +geese,for bones and leather. bring at least 1 male and 2 females for the 2 early nestboxes. +"" +Also bring logs for beds if embarking in an area without many trees. +"" +See ldog's Dreamfort embark profile for a more advanced approach: +https://drive.google.com/file/d/1Et42JTzeYK23iI5wrPMsFJ7lUXwVBQob/view?usp=sharing +"#ignore Add these lines to the bottom of your ""prefs/embark_profiles.txt"" file to make the ""Dreamfort"" profile available in-game. Also see ldog's dreamfort embark profile for a more advanced, dwarfy approach." +[PROFILE] +[TITLE:Dreamfort] +[SKILL:1:JUDGING_INTENT:1] +[SKILL:1:APPRAISAL:2] +[SKILL:1:ORGANIZATION:1] +[SKILL:1:RECORD_KEEPING:1] +[SKILL:1:MILITARY_TACTICS:5] +[SKILL:2:MINING:5] +[SKILL:2:ENGRAVE_STONE:4] +[SKILL:2:SWIMMING:1] +[SKILL:3:MINING:5] +[SKILL:3:ENGRAVE_STONE:4] +[SKILL:3:SWIMMING:1] +[SKILL:4:CUT_STONE:5] +[SKILL:4:CARVE_STONE:5] +[SKILL:5:STONECRAFT:5] +[SKILL:5:MECHANICS:5] +[SKILL:6:WOODCUTTING:5] +[SKILL:6:CARPENTRY:5] +[SKILL:7:PLANT:5] +[SKILL:7:CUT_STONE:5] +[ITEM:10:CLOTH:NONE:CREATURE_MAT:SPIDER_CAVE:SILK] +[ITEM:100:WOOD:NONE:PLANT_MAT:WILLOW:WOOD] +[ITEM:30:BLOCKS:NONE:INORGANIC:QUARTZITE] +[ITEM:21:SEEDS:NONE:PLANT_MAT:MUSHROOM_HELMET_PLUMP:SEED] +[ITEM:21:SEEDS:NONE:PLANT_MAT:GRASS_TAIL_PIG:SEED] +[ITEM:21:SEEDS:NONE:PLANT_MAT:GRASS_WHEAT_CAVE:SEED] +[ITEM:21:SEEDS:NONE:PLANT_MAT:POD_SWEET:SEED] +[ITEM:21:SEEDS:NONE:PLANT_MAT:BUSH_QUARRY:SEED] +[ITEM:21:SEEDS:NONE:PLANT_MAT:MUSHROOM_CUP_DIMPLE:SEED] +[ITEM:1:ANVIL:NONE:INORGANIC:IRON] +[ITEM:2:WEAPON:ITEM_WEAPON_AXE_BATTLE:INORGANIC:COPPER] +[ITEM:2:WEAPON:ITEM_WEAPON_PICK:INORGANIC:COPPER] +[ITEM:21:DRINK:NONE:PLANT_MAT:GRASS_TAIL_PIG:DRINK] +[ITEM:20:DRINK:NONE:PLANT_MAT:MUSHROOM_HELMET_PLUMP:DRINK] +[ITEM:20:DRINK:NONE:PLANT_MAT:POD_SWEET:DRINK] +[ITEM:20:DRINK:NONE:PLANT_MAT:GRASS_WHEAT_CAVE:DRINK] +[ITEM:30:PLANT:NONE:PLANT_MAT:MUSHROOM_HELMET_PLUMP:STRUCTURAL] +[ITEM:45:BOULDER:NONE:INORGANIC:QUARTZITE] +[ITEM:21:THREAD:NONE:CREATURE_MAT:SPIDER_CAVE:SILK] +[ITEM:3:CHAIN:NONE:CREATURE_MAT:SPIDER_CAVE:SILK] +[PET:2:DOG:FEMALE:STANDARD] +[PET:1:DOG:MALE:STANDARD] +[PET:2:CAT:FEMALE:STANDARD] +[PET:1:CAT:MALE:STANDARD] +[PET:2:BIRD_GOOSE:FEMALE:STANDARD] +[PET:2:BIRD_GOOSE:MALE:STANDARD] +#notes label(surface_help) surface level walkthrough +Sets up a protected entrance to your fort in a flat area on the surface. +Screenshot: https://drive.google.com/file/d/1dlu3nmwQszav-ZaTx-ac28wrcaYBQc_t +"" +Features: +- A starting set of workshops and stockpiles (which you can later remove once you establish your permanent workshops and storage) +"- Livestock grazing area, nestbox zones, and beehives" +"- Walls, roof, and lever-controlled gates for security" +- Barracks (with prisoner processing quantum dump) +- Trap-filled hallways for invaders +- Optional extended trap hallways (to handle larger sieges with a smaller/no military) +"- Protected trade depot, with separate trade goods stockpiles for organics and inorganics (for safe elven trading)" +- A grid of small farm plots for lucrative surface farming +"- A burrow named ""Inside+"" that grows with your fort as you dig it out. It is pre-registered as a civilian alert burrow so you can use it to get your civilians to safety during sieges." +"- A burrow named ""Clearcutting area"" that is automatically registered with autochop (if you have it enabled) to keep the area around your fort clear of trees. This prevents invaders from jumping over your walls. Moreover, it prevents trees from growing large near your exterior walls. If those trees are chopped down so they fall on the fort, they can collapse the roof." +"" +Manual steps you have to take: +"- Assign grazing livestock to the large pasture, dogs to the pasture over the central stairs, and male birds to the zone between the rows of nestboxes (DFHack's autonestbox will auto-assign the female egg-laying birds to the nestbox zones)" +- Connect levers to the drawbridges that match the names of the levers +- Assign minecarts to the trade goods and prisoner processing quantum stockpile hauling routes with assign-minecarts all +"" +Be sure to choose an embark site that has a flat area on the surface large enough to use these blueprints! +"" +Surface Walkthrough: +"1) Choose a tile for your central fortress stairs. The terrain around that tile should be perfectly flat. Trees are ok, but no slopes, rivers, or ponds. To be sure that the tile you've chosen is in a good spot, run ""gui/quickfort dreamfort /perimeter"". This will show you the eventual boundaries of the fort. Some wall segments might be missing due to existing trees, but that's ok. Make sure the area within the exterior wall is flat. Cancel out of the preview. You don't actually need to apply this blueprint. You may want to double-check your selected area with gui/biomes to make sure your surface farm plots (to the left of the central tile) will be in a biome that you want to grow in (e.g. you cannot grow surface plants in mountain biomes). Also, the biome to the north of the central tile will hold the underground farm plots, so be sure it has soil." +"" +"2) With the cursor on the chosen tile, run /surface1 to clear surrounding trees and set up your pastures. Deconstruct your wagon to get it out of the way of our upcoming walls and floors. Remember to assign your dogs to the pasture around the staircase, your grazing animals to the large pasture, and your male birds to the zone between the nestboxes. Your female egg-layers will automatically get assigned to nestbox zones once the nestboxes are built, so you don't need to worry about them. You can let your cats roam free to chase vermin." +"" +"3) Once the marked trees have been cleared, run /surface2 to setup starting workshops/stockpiles, channel out the miasma vents for the farming level, and start clearing trees from a larger area. If you haven't done it already, now is a good time to configure buildingplan to only build buildings with blocks, not logs or raw boulders. Generate manager orders for /surface2 if you haven't already preordered with the checklist command." +"" +"4) Once the channels are dug out and the trees are cleared, start digging the farming level one z-level down. Once you have run /farming2, come back to the surface and run /surface3 to cover the vents and build an enclosure around your central stairs. Although the vents will be covered with flooring (or solid walls), they will still work to prevent miasma on the farming level. Generate manager orders for /surface3 if you haven't already preordered with the checklist command." +"" +"5) Once all walls and floors have been constructed around the stairwell, run /surface4 to build floors and walls to support upcoming buildings and furniture. Generate manager orders for /surface4 if you haven't already preordered with the checklist command." +"" +"6) Once walls and floors have been constructed (including the small roof segment one z-level up over the barracks), run /surface5 to build furniture and the drawbridge gates. This blueprint also clearcuts the trees from around the exterior walls. The blueprint may appear to extend off the map or into a nearby hill, but that is ok. Generate manager orders for /surface5." +"" +"7) Once all marked trees are cleared, run /surface6 to build the security perimeter and remaining flooring. Generate manager orders for /surface6." +"" +"8) Once you have enough dwarves to do a lot of building without starving other important tasks, run /surface7 to build the roof. This blueprint also sets up the autochop-integrated clearcutting area, so it may extend off the map or into nearby hills. It is not a problem if that happens. Generate manager orders for /surface7." +"" +"9) For extra security, you can run /surface8 any time after /surface7 to extend the trap corridors. Generate manager orders for /surface8." +"" +"10) Once your industry and farming levels are set up and running, you can disassemble the surface workshops and remove the surface stockpiles. Disassembling a workshop scatters the items stored within it and cancels any pending jobs that happen to use those items. In order to avoid job cancellations, first set the surface workshops to not accept general work orders (click on the building, select the ""Work orders"" tab, and set the ""General work orders allowed"" to 0). Then check to see if any items in a workshop are marked as being part of an active job. Once no items in the workshop have that marker, you are free to disassemble that workshop." +"" +Sieges and Prisoner Processing: +Here are some tips and procedures for handling seiges -- including how to clean up afterwards! +"" +"- Your ""Inside+"" burrow will automatically grow with your fort and should include only safe areas. In particular, it does not include the ""atrium"" area (where the ""siege bait"" pasture is) or the trapped hallways." +"" +"- When a siege begins, set your civilian alert (attach the alert to your ""Inside+"" burrow if it isn't already) to ensure all your civilians stay out of danger. Immediately pull the lever to close the outer main gate. It is also wise to close the trade depot and inner main gate as well. That way, if enemies get past the traps, they'll have to go through the soldiers in your barracks (assuming you have a military)." +"" +"- During a siege, you can use the levers to control how attackers path through the trapped corridors. If there are more enemies than cage traps, time your lever pulling so that the inner gates snap closed before your last cage trap is sprung. Then the remaining attackers will have to backtrack and go through the other trap-filled hallway. You can also choose *not* to use the trap hallways and instead meet the siege head-on with your military. It's up to you!" +"" +"- If your cage traps fill up, ensure your hallways are free of uncaged attackers, then close the trap hallway outer gates and open the inner gates. Clear the civilian alert and allow your dwarves to reset all the traps -- make some extra cages in preparation for this! Then re-enable the civilian alert and open the trap hallway outer gates." +"" +"- Once the last attacker is caged, open all the gates and unset the civilian alert. Life is normal again!" +"" +"After a siege, you can use the caged prisoners to safely train your military. Here's how:" +"" +"- Once the prisoners are hauled to the ""prisoner quantum"" stockpile in the barracks, run ""stripcaged all"" in DFHack's gui/launcher." +"" +"- After all the prisoners' items have been confiscated, bring your military dwarves to the barracks (if they aren't already there)." +"" +- Assign a group of prisoners to the pasture that overlaps the prisoner quantum stockpile +"" +"- Hauler dwarves will come and release prisoners one by one. Your military dwarves will immediately pounce on the released prisoners and chop them to bits, saving the hauler dwarves from being attacked. Repeat until all prisoners have been ""processed"". Some prisoners are not directly hostile (like cavern-caught gorlaks) and you may need to be target them explicitly to get your soldiers to attack them." +#dig label(central_stairs_odd) start(2;2) hidden() carved spiral stairs odd levels +`,j6,` +u,`,u +`,j6,` +#meta label(central_stairs_even) hidden() carved spiral stairs even levels +/central_stairs_odd transform(cw) +#meta label(central_stairs) two levels of carved spiral stairs (repeat down as needed) +/central_stairs_odd +#> +/central_stairs_even +#build label(central_stairs_odd_constructed) start(2;2) hidden() constructed spiral stairs odd levels +`,Cd,` +Cu,`,Cu +`,Cd,` +#meta label(central_stairs_even_constructed) hidden() constructed spiral stairs even levels +/central_stairs_odd_constructed transform(cw) +#meta label(central_stairs_constructed) two levels of constructed spiral stairs (repeat down as needed) +/central_stairs_odd_constructed +#> +/central_stairs_even_constructed +"#meta label(perimeter) start(central stairs) message(If you accidentally applied this blueprint to the map, run quickfort undo on this blueprint to clean up.) show the eventual perimeter of the surface fort; useful for location scouting. DO NOT APPLY." +walls/surface_walls +corridor_gates/surface_corridor_gates +corridor/surface_corridor +corridor_traps/surface_corridor_traps +"" +"#meta label(surface1) start(central stairs) +message(Once the central stairs are mined out deeply enough, you should start digging the industry level in a non-aquifer rock layer. You'll need the boulders from the digging to make blocks. +If your wagon is within the fort perimeter, deconstruct it to get it out of the way. +Once the marked trees are all chopped down (if any), continue with /surface2.) clear trees and set up pastures" +clear_small/surface_clear_small +burrow_start/surface_burrow_start +zones/surface_zones +#> +central_stairs/central_stairs repeat(down 10) +"" +"#meta label(surface2) start(central stairs) message(If you preordered items on the checklist, good. If not, don't forget to generate orders for this blueprint now. +Once the channels are dug out and the marked trees are cleared, continue with /surface3.) set up starting workshops/stockpiles, channel miasma vents, and clear more trees" +place_start/surface_place_start +build_start/surface_build_start +channel/surface_channel +clear/surface_clear +"" +"#meta label(surface3) start(central stairs) message(If you preordered items on the checklist, good. If not, don't forget to generate orders for this blueprint now. +Once the walls and floors around the staircase have been constructed, continue with /surface4.) Cover vents and protect the central stairs." +cover_vents/surface_cover_vents +cover_stairs/surface_cover_stairs +"" +"#meta label(surface4) start(central stairs) message(If you preordered items on the checklist, good. If not, don't forget to generate orders for this blueprint now. +Once the bits of flooring have been constructed, continue with /surface5. Be sure to check one z-level above the surface to ensure the roof segment above the future barracks has been finished.) build walls and flooring to support upcoming buildings and furniture" +stairs_doors/surface_stairs_doors +pre_building/surface_pre_building +"" +"#meta label(surface5) start(central stairs) message(Remember to enqueue manager orders for this blueprint. +Once the marked trees are cleared, continue with /surface6.) build gates, furniture, and trade stockpile/depot" +traffic/surface_traffic +place/surface_place +build/surface_build +clear_large/surface_clear_large +"" +"#meta label(surface6) start(central stairs) message(Remember to enqueue manager orders for this blueprint. +Continue with /surface7 sometime after the walls are completed and any marked trees are chopped down, whenever you have enough dwarves to build the roof without starving other important construction tasks.) build traps and remaining walls/floors" +walls/surface_walls +floors/surface_floors +traps/surface_traps +clear_large/surface_clear_large +"" +"#meta label(surface7) start(central stairs (on ground level)) message(Remember to enqueue manager orders for this blueprint. +For extra security, you can run /surface8 at any time to extend the trap corridors.) expand Inside+ burrow to safe surface areas and build roof" +burrows/surface_burrows +#< +roof/surface_roof +roof2/surface_roof2 +roof3/surface_roof3 +roof4/surface_roof4 +"" +#meta label(surface8) start(central stairs) message(Remember to enqueue manager orders for this blueprint.) build extended trap corridors +corridor_gates/surface_corridor_gates +corridor/surface_corridor +corridor_traps/surface_corridor_traps +#dig label(surface_clear_small) start(19; 19) hidden() clear trees for starting workshops and stockpiles + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,t1(25x11),,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,t1,`,`,`,`,`,`,,`,,`,`,`,`,`,t1,`,`,`,t1,`,`,,` +,,,`,,`,,`,t1,t1,,,,,,`,t1,t1,t1,t1,t1,`,,,,t1(5x5),,,,,,`,,` +,,,`,,`,,`,,,,,,,,,t1,t1,t1,t1,t1,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,t1,j,t1,j,t1,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,t1,t1,t1,t1,t1,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,t1,t1,t1,t1,t1,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,t1,,,,,,t1,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,t1,t1,,,,,,t1,t1,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,t1,t1,,t1,t1,t1,,t1,t1,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,t1,t1,t1,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,t1,,,t1,t1,t1,,,t1,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,t1,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#burrow label(surface_burrow_start) start(19; 19) hidden() create safety burrow that will grow with your fort + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,`,`,,`,`,,` +,,,`,,`,,`,,,,,,,,`,a{name=Inside+ create=true civalert=true}(5x5),,,,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,~,,~,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +"#zone label(surface_zones) start(19; 19) hidden() message(Remember to assign your dogs to the pasture surrounding the central stairs, your grazing animals to the large pasture, and your male birds to the zone between the rows of nestboxes. If your wagon is far away, you can let your animals wander closer to the fort before pasturing them to save hauling time.) pastures and training areas" + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,"n{name=""Main pasture""}(25x11)",,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,"t{name=""Pet training area""}(9x5)",,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,"n{name=""Nestbox 1""}(1x1)","n{name=""Nestbox 2""}(1x1)","n{name=""Nestbox 3""}(1x1)","n{name=""Nestbox 4""}(1x1)","n{name=""Nestbox 5""}(1x1)","n{name=""Nestbox 6""}(1x1)","n{name=""Nestbox 7""}(1x1)",`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,"n{name=""Male birds""}(7x3)",,,,,,,,"n/guarddogs{name=""Guard dogs""}(5x1)",~,~,~,~,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,~,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,n/guarddogs(5x1),~,~,~,~,,,,,,,,,,,`,,` +,,,`,,`,,`,"n{name=""Nestbox 8""}(1x1)","n{name=""Nestbox 9""}(1x1)","n{name=""Nestbox 10""}(1x1)","n{name=""Nestbox 11""}(1x1)","n{name=""Nestbox 12""}(1x1)","n{name=""Nestbox 13""}(1x1)","n{name=""Nestbox 14""}(1x1)",`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,m/welcome(7x1),,,,,,,`,,` +,,,`,,`,"B{name=""Surface barracks""}",B,B,B,B,B,B,B,`,,,,,,,,`,"m/welcome{name=""Welcome area/wagon parking lot""}(8x5)",,,,,,,,`,,` +,,,`,,`,B,B,B,B,B,B,B,B,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,B,B,B,B,B,B,B,B,,,,,"n{name=""Siege bait pasture""}",,,,,,,,,,,,,`,,` +,,,`,,`,B,B,B,B,B,B,B,B,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,B,B,B,B,B,B,"n{name=""Prisoner processing pen""}(1x2)",B,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#place label(surface_place_start) start(19; 19) hidden() starting stockpiles + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,"hlr{name=""Starting cloth/trash"" containers=0}(15x2)",,,,,,,,,,,,,,,,"gunzSpd{name=""Starting misc"" containers=0}(9x4)",,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,"w{name=""Starting wood""}(4x4)",,,,~,~,~,,"s2{name=""Starting stone""}:=otherstone(7x3)",,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,~,~,~,,,,,,,,,,"f{name=""Starting food""}(9x2)",,,,,,,,,`,,` +,,,`,,`,,,,,~,~,~,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,,,,,~,~,~,,~,~,~,,~,~,~,,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,,~,~,~,,~,~,~,,~,~,~,,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,,~,~,~,,~,~,~,,~,~,~,,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,,,,,,,,,,,,,,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,~,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_build_start) start(19; 19) hidden() starting workshops + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,~,~,~,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,~,"wt{name=""Starter mechanic's"" do_now=true}",~,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,~,~,~,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,~,~,~,,~,~,~,,~,~,~,,,,,,,,,,,`,,` +,,,`,,`,,,,,~,"wc{name=""Starter carpenter"" do_now=true}",~,,~,"wr{name=""Starter craftsdwarf's"" do_now=true}",~,,~,"wm{name=""Starter stoneworker's"" do_now=true max_general_orders=2}",~,,,,,,,,,,,`,,` +,,,`,,`,,,,,~,~,~,,~,~,~,,~,~,~,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,N{do_now=true},N{do_now=true},,,,,,`,,,,,,`,,,,~,~,~,~,~,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,~,~,~,~,~,,`,,` +,,,`,,`,,,,,,,,,,`,,`,~,`,,`,,,,~,~,D{do_now=true},~,~,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,~,~,~,~,~,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,~,~,~,~,~,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#dig label(surface_channel) start(19; 19) hidden() channel miasma vents + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,h1,`,`,`,`,`,`,,`,,`,`,`,`,`,h1,`,`,`,h1,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,~,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,h1,,,,,,h1,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,h1,h1,,,,,,h1,h1,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,h1,h1,,h1,h1,h1,,h1,h1,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,h1,h1,h1,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,h1,,,h1,h1,h1,,,h1,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,h1,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#dig label(surface_clear) start(19; 19) hidden() clear trees so the farming level can be dug without fear of generating surface holes + + +,,,t1(31x29) +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,`,`,,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,~,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + +,,,,,,,,,,,,,,,t1,t1,t1,t1,t1,t1,t1 + +#build label(surface_cover_vents) start(19; 19) hidden() cover the miasma vents + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,Cw,`,`,`,`,`,`,,`,,`,`,`,`,`,Cw,`,`,`,Cw,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,~,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,Cf,,,,,,Cf,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,Cf,Cf,,,,,,Cf,Cf,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,Cf,Cf,,Cf,Cf,Cf,,Cf,Cf,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,Cf,Cf,Cf,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,Cw,,,Cf,Cf,Cf,,,Cw,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,Cf,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_cover_stairs) start(19; 19) hidden() protect the central stairs + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,Cw,Cw,Cf,Cw,Cf,Cw,Cw,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,Cw,,,,,,Cw,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,Cf,,`,`,`,,Cf,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,Cw,,H,~,H,,Cw,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,Cf,,`,`,`,,Cf,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,Cw,,,,,,Cw,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,Cw,Cw,Cf,Cw,Cf,Cw,Cw,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_stairs_doors) start(19; 19) hidden() + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,Cr{do_now=true},,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,d,`,d,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,d,,`,`,`,,d,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,`,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,d,,`,`,`,,d,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,d,`,d,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#< + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,Cf{do_now=true},`,Cf,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,Cf,Cf{do_now=true},Cf,Cf,Cf,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf,Cf,Cf,Cf,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,Cf,Cf,Cf,Cf,Cf,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,Cf{do_now=true},Cf,Cf,Cf,Cf,Cf,Cf,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,Cf,Cf,Cf,Cf,Cf,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,Cf,`,Cf,`,`,`,`,,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_pre_building) start(19; 19) hidden() flooring and anchoring walls for future buildings/doors +#< + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,~,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,~,`,~,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,~,~,~,~,~,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,~,~,~,~,~,~,~,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,~,~,~,~,~,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},~,~,~,~,~,~,~,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,Cf{do_now=true},,,`,~,~,~,~,~,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,Cf{do_now=true},`,`,`,`,~,`,~,`,`,`,`,,,,,,,,`,,` +,,,`,,`,Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,Cf{do_now=true},,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,Cf{do_now=true},,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,Cf{do_now=true},,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},Cf{do_now=true},,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#> + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,~,~,N,N,N,N,N,`,Cf,,Cf,,Cf,`,Cf,Cf,,~,~,~,~,~,,`,,` +,,,`,,`,,Cw,,,,,,,,,,`,`,`,,,Cf,Cf,,~,~,~,~,~,,`,,` +,,,`,,`,,Cf,,,,,,,,`,,`,`,`,,`,Cf,Cf,,~,~,~,~,~,,`,,` +,,,`,,`,,Cw,,,,,,,,,,`,`,`,,,Cf,Cf,,~,~,~,~,~,,`,,` +,,,`,,`,,`,,,,,,,,`,Cf,Cf,Cf,Cf,Cf,`,Cf,Cf,,~,~,~,~,~,,`,,` +,,,`,,`,`,`,`,`,`,Cw,Cf,Cw,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,Cf,Cf,Cf,Cf,Cf,,,,`,~,Cf,Cf,Cf,Cf,Cf,~,`,,,,,,,,,`,,` +,,,`,,`,Cf,Cf,Cf,Cf,Cf,,,,~,~,Cf,Cf,Cf,Cf,Cf,~,~,,,,,,,,,`,,` +,,,`,,`,Cf,Cf,,,,,,,~,~,,~,~,~,,~,~,,,,,,,,,`,,` +,,,`,,`,Cf,Cf,Cf,Cf,Cf,,Cf,,Cf,Cf,,~,~,~,,Cf,Cf,,,,,,,,,`,,` +,,,`,,`,Cf,Cf,Cf,Cf,Cf,,Cf,,`,,,~,~,~,,,`,Cf,,Cf,,,Cf,,Cf,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,Cf,Cf,,,,,,,,Cf,Cf,,,,~,,,,Cf,Cf,,,,,,,,Cf,Cf,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,`,`,`,`,`,`,`,`,`,`,` + + + +#dig label(surface_traffic) start(19; 19) hidden() set traffic designations + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,`,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,or,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,or,`,or,or,ol,ol,ol,ol,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,or,ol,ol,or,ol,ol,ol,ol,ol,ol,,,,,,,,,`,,` +,,,`,,`,,,,,,,,or,ol,ol,or,,,,,ol,ol,,,,,,,,,`,,` +,,,`,,`,,,,,,,,or,ol,ol,or,,,,,ol,ol,,,,,,,,,`,,` +,,,`,,`,,,,,,,,or,`,or,or,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,ol,ol,ol,ol,ol,ol,ol,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,ol,ol,ol,ol,ol,ol,ol +,,,,,,,,,,,,,,,ol,ol,ol,ol,ol,ol,ol + +"#place label(surface_place) start(19; 19) hidden() message(Remember to assign minecarts to the trade goods and prisoner processing quantum stockpiles (run ""assign-minecarts all""). +Feel free to adjust the configuration of the ""trade goods"" feeder stockpile so it accepts the item types you want to trade away. If those items types are also accepted by other stockpiles, configure those stockpiles to give to the ""trade goods"" stockpile. +The inorganic trade goods stockpile is set to autotrade, but you can toggle that according to your preference.) remaining surface stockpiles" + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,"a10{name=""Pets/Prisoner feeder"" autotrain=true}(9x5)",,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,"c{name=""Organic trade goods quantum"" quantum=true}:+all",,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,"g{name=""Trade goods"" containers=0}:-cat_finished_goods/type/,core/artifact+crafts(2x3)",,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,`,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,"c{name=""Inorganic trade goods quantum"" autotrade=true quantum=true}:+all-organic",,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,"a{name=""Prisoner/cage quantum"" autotrain=true quantum=true}",,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +"#build label(surface_build) start(19; 19) hidden() message(Use autofarm to manage farm crop selection. +Remember to connect the levers to the gates once they are built.) gates, barracks, farm area, and trade area" + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,~,~,~,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,~,"ww{name=""Milking/shearing station"" labor=""Milking, Shearing""}",~,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,~,~,~,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,~h{do_install=true do_gather=true}(1x1),`,~,~,~,~,~,~,~,`,"Tl{name=""Barracks gate"" do_now=true}",,"Tl{name=""Inner main gate"" do_now=true}",,"Tl{name=""Trade depot gate"" do_now=true}",`,"trackstopE{name=""Organic trade goods dumper"" take_from=""Trade goods"" route=""Organic trade goods quantum""}",,,~,~,~,~,~,,`,,` +,,,`,,`,~h{do_install=true do_gather=true}(1x1),`,p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),,,`,`,`,,,,,,~,~,~,~,~,,`,,` +,,,`,,`,"~h{name=""reserved for splitting"" do_install=true}(1x1)",d,p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),`,,`,`,`,,`,,,,~,~,~,~,~,,`,,` +,,,`,,`,~h{do_install=true do_gather=true}(1x1),`,p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),p(1x1),,,`,`,`,,,,,,~,~,~,~,~,,`,,` +,,,`,,`,~h{do_install=true do_gather=true}(1x1),`,N,N,N,N,N,N,N,`,"Tl{name=""Left outer gate"" do_now=true}(1x1)","Tl{name=""Left inner gate"" do_now=true}(1x1)","Tl{name=""Outer main gate"" do_now=true}(1x1)","Tl{name=""Right inner gate"" do_now=true}(1x1)","Tl{name=""Right outer gate"" do_now=true}(1x1)",`,"trackstopE{name=""Inorganic trade goods dumper"" take_from=""Trade goods,Organic trade goods quantum"" route=""Inorganic trade goods quantum""}:-organic",,,~,~,~,~,~,,`,,` +,,,`,,`,`,`,`,`,`,`,d,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,b,b,b,b,b,,,,`,,"gw{name=""Inner main gate"" do_now=true}",gw,gw,gw,gw,,`,,,,,,,,,`,,` +,,,`,,`,h,h,h,h,h,,,,"ga{name=""Barracks gate"" do_now=true}",ga,gw,gw,gw,gw,gw,"gd{name=""Trade depot gate"" do_now=true}",gd,,,,,,,,,`,,` +,,,`,,`,a,r,,,,,,,ga,ga,,,,,,gd,gd,,,,,,,,,`,,` +,,,`,,`,h,h,h,h,h,,"trackstopS{name=""Prisoner/cage dumper"" take_from=""Pets/Prisoner feeder"" route=""Prisoner/cage quantum""}:-cat_animals/tameable",,ga,ga,,,,,,gd,gd,,,,,,,,,`,,` +,,,`,,`,b,b,b,b,b,,,,`,,,,,,,,`,s,,s,,,s,,s,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,"gd{name=""Left outer gate"" do_now=true}",gd,,,,,,,,"gd{name=""Left inner gate"" do_now=true}",gd,,,,,,,,"ga{name=""Right inner gate"" do_now=true}",ga,,,,,,,,"ga{name=""Right outer gate"" do_now=true}",ga,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,"gw{name=""Outer main gate"" do_now=true}",gw,gw,gw,gw,gw,gw,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,gw,gw,gw,gw,gw,gw,gw +,,,,,,,,,,,,,,,gw,gw,gw,gw,gw,gw,gw + +#dig label(surface_clear_large) start(19; 19) hidden() clear wider area of trees +t1(37x33) + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,~,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_walls) start(19; 19) hidden() build remaining walls + + + +,,,`,,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,Cw,Cw,Cw,Cw,~,Cw,Cw,Cw,Cw,~,~,,~,,~,~,Cw,Cw,Cw,~,Cw,Cw,Cw,~,Cw,Cw,,` +,,,`,,Cw,,Cw,,,,,,,,~,,,,,,~,,,,,,,,,,Cw,,` +,,,`,,Cw,,~,,,,,,,,,,`,`,`,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,~,,`,`,`,,~,,,,,,,,,,Cw,,` +,,,`,,Cw,,~,,,,,,,,,,`,`,`,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,Cw,,,,,,,,~,,,,,,~,,,,,,,,,,Cw,,` +,,,`,,Cw,Cw,Cw,Cw,Cw,Cw,~,,~,Cw,~,~,,~,,~,~,Cw,Cw,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,Cw,,,,,,,,Cw,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,Cw,,` +,,,`,,Cw,,,,,,,,,~,,,,,,,,~,,,,,,,,,Cw,,` +,,,`,,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,,,,,,,,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,,,,,,,,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,Cw,`,` + + + +#build label(surface_floors) start(19; 19) hidden() build remaining flooring + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,~,`,~,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,~,Cf,~,Cf,~,`,~,~,Cf,~,~,~,~,~,Cf,`,,` +,,,`,,`,,`,,,,,,,,~,Cf,Cf,Cf,Cf,Cf,~,~,~,Cf,~,~,~,~,~,Cf,`,,` +,,,`,,`,,~,,,,,,,,`,Cf,`,Cf,`,Cf,`,~,~,Cf,~,~,~,~,~,Cf,`,,` +,,,`,,`,,`,,,,,,,,~,Cf,Cf,Cf,Cf,Cf,~,~,~,Cf,~,~,~,~,~,Cf,`,,` +,,,`,,`,,`,,,,,,,,`,~,~,~,~,~,`,~,~,Cf,~,~,~,~,~,Cf,`,,` +,,,`,,`,`,`,`,`,`,`,~,`,`,`,`,~,`,~,`,`,`,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,~,~,~,~,Cf,Cf,Cf,`,~,~,~,~,~,~,~,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,~,~,~,~,Cf,Cf,Cf,~,~,~,~,~,~,~,~,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,~,Cf,Cf,Cf,Cf,Cf,Cf,~,~,Cf,~,~,~,Cf,~,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,~,~,~,~,Cf,~,Cf,~,~,Cf,~,~,~,Cf,~,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,~,~,~,~,Cf,~,Cf,`,Cf,Cf,~,~,~,Cf,Cf,`,~,Cf,~,Cf,Cf,~,Cf,~,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,`,`,`,`,`,`,`,`,`,,` +,,,`,~,,,,,,,,,,,Cf,Cf,Cf,~,Cf,Cf,Cf,,,,,,,,,,,~,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_traps) start(19; 19) hidden() + +,,,,,Tc,,,,,,,,,,,,,,,,,,,,,,,,,,Tc +,,,,,Tc,,,,,,,,,,,,,,,,,,,,,,,,,,Tc +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,`,`,`,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,Tc,Tc,Tc,Tc,Tc,Tc,Tc,,,,,,,,,,,,Tc,Tc,Tc,Tc,Tc,Tc,Tc,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,Tc,Tc,,,,,,,,Tc,Tc +,,,,,,,,,,,,,Tc,Tc,,,,,,,,Tc,Tc + +#burrow label(surface_burrows) start(19; 19) hidden() extend safety burrow to newly safe surface areas and set up surrounding clearcutting area + + +,,,,"a{name=""Clearcutting area"" create=true autochop_clear=true}(-12x-10)","a{name=""Clearcutting area"" create=true autochop_clear=true}(28x-10)",,,,,,,,,,,,,,,,,,,,,,,,,,,"a{name=""Clearcutting area"" create=true autochop_clear=true}(12x-10)" +,,,`,"a{name=""Clearcutting area"" create=true autochop_clear=true}(-12x27)",`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,"a{name=""Clearcutting area"" create=true autochop_clear=true}(12x27)",` +,,,`,,`,a{name=Inside+}(25x17),,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,`,`,,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,,~,,~,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,a{name=Inside+}(8x7),`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,a{name=Inside+}(8x7),,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,,,"a{name=""Clearcutting area"" create=true autochop_clear=true}(-12x10)","a{name=""Clearcutting area"" create=true autochop_clear=true}(28x10)",,,,,,,,,,,,,,,,,,,,,,,,,,,"a{name=""Clearcutting area"" create=true autochop_clear=true}(12x10)" + + +#build label(surface_roof) start(19; 19) hidden() roof hatch and adjacent tiles + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,Cf,,Cf,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,Cf,"H{name=""Roof access""}",Cf,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,~,`,~,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,Cf,`,,,,,,,,`,~,~,~,~,~,`,,,,,,,,,,`,,` +,,,`,,`,Cf,`,,,,,,,,~,~,~,~,~,~,~,,,,,,,,,,`,,` +,,,`,,`,Cf,Cf,,,,,,,,`,~,~,~,~,~,`,,,,,,,,,,`,,` +,,,`,,`,Cf,`,,,,,~,~,~,~,~,~,~,~,~,~,,,,,,,,,,`,,` +,,,`,,`,Cf,`,,,,,~,,,`,~,~,~,~,~,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,~,`,`,`,`,~,`,~,`,`,`,`,,,,,,,,`,,` +,,,`,,`,~,~,~,~,~,~,~,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,~,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,~,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,~,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,~,~,~,~,~,~,~,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_roof2) start(19; 19) hidden() lower half of the roof + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,~,,~,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,~,~,~,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,~,`,~,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,~,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,~,~,~,~,~,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,~,~,~,~,~,~,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,~,~,~,~,~,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,`,Cf,Cf,Cf,Cf,~,~,~,~,~,~,~,~,~,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,`,Cf,Cf,Cf,Cf,~,Cf,Cf,`,~,~,~,~,~,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,`,`,`,`,`,`,~,`,`,`,`,~,`,~,`,`,`,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,~,~,~,~,~,~,Cf,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,Cf,Cf,Cf,Cf,Cf,Cf,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,Cf,Cf,Cf,Cf,Cf,Cf,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,Cf,Cf,Cf,Cf,Cf,Cf,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,~,~,~,~,~,~,~,Cf,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_roof3) start(19; 19) hidden() upper half center of the roof + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,~,Cf,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,~,~,~,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,~,`,~,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,`,`,`,`,`,`,~,`,`,`,`,~,`,~,`,`,`,`,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_roof4) start(19; 19) hidden() upper half remainder of the roof + + + +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,~,`,~,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,`,`,`,`,`,`,~,`,`,`,`,~,`,~,`,`,`,`,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,~,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,~,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_corridor_gates) start(19; 19) hidden() message(Remember to connect the levers to the new external trap gates.) gates for the longer trap hallways + + +,,,,"gx{name=""Left trap gate"" do_now=true}",,,,,,,,,,,,,,,,,,,,,,,,,,,,"gx{name=""Right trap gate"" do_now=true}" +,,,`,gx,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,gx,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,`,"Tl{name=""Left trap gate"" do_now=true}",`,`,`,"Tl{name=""Right trap gate"" do_now=true}",`,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,` +,,,`,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,` +,,,`,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,` +,,,`,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_corridor) start(19; 19) hidden() longer trap hallway walls + + +,,,,~,,,,,,,,,,,,,,,,,,,,,,,,,,,,~ +,,,Cw,~,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,~,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,,Cw +,,,Cw,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,Cw +,,,Cw,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,`,~,`,`,`,~,`,,,,,,,,,,`,,Cw +,,,Cw,,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,,Cw +,,,Cw,,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,,Cw +,,,Cw,,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,,Cw +,,,Cw,,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,,Cw +,,,Cw,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,Cw +,,,Cw,Cw,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,Cw,Cw + + + +#< + + + +,,,`,Cf,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,`,`,`,`,`,`,`,`,`,`,`,~,`,~,`,`,`,`,`,`,`,`,`,`,`,`,Cf,` +,,,`,Cf,`,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,`,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,`,`,`,`,`,`,~,`,`,`,`,~,`,~,`,`,`,`,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,~,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,`,~,~,~,~,~,~,~,~,`,Cf,` +,,,`,Cf,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,Cf,` +,,,`,Cf,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,~,Cf,` +,,,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,`,` + + + +#build label(surface_corridor_traps) start(19; 19) hidden() traps for the longer trap hallways + + +,,Tc,Tc,~,,,,,,,,,,,,,,,,,,,,,,,,,,,,~,Tc,Tc +,,Tc,`,~,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,~,`,Tc +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,`,`,`,Tc,` +,,,`,Tc,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,`,~,`,`,`,~,`,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,`,,,,,,,,,,`,`,`,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,`,,,,,,,,`,,,,,,`,,,,,,,,,,`,Tc,` +,,,`,Tc,`,`,`,`,`,`,`,,`,`,`,`,,`,,`,`,`,`,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,,,,,,,,,,,,,,,,,,`,Tc,` +,,,`,Tc,`,,,,,,,,,`,,,,,,,,`,,,,,,,,,`,Tc,` +,,,`,Tc,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,Tc,` +,,,`,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,Tc,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,Tc +,,Tc,Tc,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,Tc,Tc + + +#notes label(farming_help) farming level walkthrough +"Sets up farming, food storage, and related industries. Also provides post-embark necessities that can later be disassembled." +Screenshot: https://drive.google.com/file/d/1vDaedLcgoexUdKREUz75ZXQi0ZSdwWwj +"" +Features: +- Pairs with the surface blueprints for vents that prevent miasma +- Farm plots (can be managed by DFHack autofarm) +- Plentiful food storage +- Refuse/corpse quantum stockpile +"- Starter dormitory, dining room, and tomb for use until more permanent versions are ready" +- Offices for your manager and bookkeeper +"" +Workshops: +- Kitchen +- Brewery +- Butcher +- Fishery +- Tannery +- Farmer's Workshop +- Quern +- Screw Press +"" +Manual steps you have to take: +"- Assign a minecart to your refuse quantum stockpile hauling route (you can run ""assign-minecarts all"" to do this)" +"" +Farming Walkthrough: +"1) Wait until you have channeled the miasma vents and cleared trees on the surface before digging out the farming level on the z-level below the surface, otherwise you will end up with extra ramps on the farming level and unprotected holes through the surface when you later chop down trees growing above empty space." +"" +2) Start digging with /farming1 and get started on manufacturing furniture by generating manager orders for /farming2 (if you haven't already preordered with the checklist command). +"" +"3) Once the level is dug out, run /farming2 to designate zones, build workshops and stockpiles, and place furniture. Remember to assign a minecart to the newly-designated quantum refuse dump with assign-minecarts all." +"" +"4) Once your fort has enough free time to build the remaining doors, run /farming3. Generate manager orders for /farming3." +"" +"5) You can disassemble the dining room and dormitory once the services and apartments levels are up and running, if you like. Also, you can turn on seasonal fertilization for the farm plots if you need to boost your crop yields." +"#dig label(farming1) start(16; 18; central stairs) message(Once the area is dug out, continue with /farming2.)" +# this level is dug at priority 3 since it is dug in soil. it's worth the miner's time to +# stop digging the industry level and quickly dig out this one. +,,,,,,,,,3,3,3,,3,3,3,3,3,,3,3,3,3 +,,,,,,,,,3,3,3,,3,3,3,3,3,,3,3,3,3 +,,,,,,,,,3,3,3,,3,3,3,3,3,,3,3,3,3 +,,,,,,,,,,,3,,3,3,3,3,3,,3,3,3,3 +,,,,,,,3,3,3,,3,,3,3,3,3,3,,3,3,3,3 +,,,,,,,3,3,3,3,3,,3,3,3,3,3,,3,3,3,3 +,,,,,,,3,3,3,,3,,3,3,3,3,3,,3 +,,,,,,,,,,,3,,3,3,3,3,3,,3,,3,3,3 +,,,,,,3,3,3,3,,3,,3,3,3,3,3,,3,3,3,3,3 +,,,,,,3,3,3,3,,3,,3,3,3,3,3,,3,,3,3,3 +,,,3,3,,3,3,3,3,,3,,3,3,3,3,3,,3 +,,3,3,3,,3,3,3,3,,3,,3,3,3,3,3,,3,,3,3,3,,3,3,3 +,,3,3,3,3,3,z3,2,2,2,2,,,3,,3,,,2,2,2,z3,2,2,2,z3,3 +,,,3,3,,3,3,3,3,,2,2,2,2,2,2,2,2,2,,3,3,3,,3,3,3 +,,,,3,,,3,,,,,,2,`,`,`,2,,,,,3,,,,3 +,,3,3,3,3,3,3,3,3,3,3,,2,`,~,`,2,,3,3,3,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,3,3,3,3,2,`,`,`,2,3,3,3,3,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,3,3,3,,2,2,2,2,2,,3,3,3,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,3,3,,,,2,,2,,,,3,3,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,3,,,z3,2,2,2,2,2,z3,,,3,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,3,,z3,z3,,,2,,,z3,z3,,3,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,,,z3,z3,,z3,z3,z3,,z3,z3,,,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,,3,2,3,,z3,z3,z3,,3,2,3,,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,,3,z3,3,,z3,z3,z3,,3,z3,3,,3,3,3,3,3,3,3 +,,3,3,3,3,3,3,3,,3,3,3,,,2,,,3,3,3,,3,3,3,3,3,3,3 +,,,,,,,,,,,,,,,z3 + + +"#meta label(farming2) start(central stairs) message(If you preordered items on the checklist, good. If not, don't forget to generate orders for this blueprint now. +Once furniture has been placed, continue with /farming3.) workshops, stockpiles, and important furniture" +zone/farming_zone +place/farming_place +build/farming_build +traffic/farming_traffic +burrow/farming_burrow +"" +#meta label(farming3) start(central stairs) message(Remember to enqueue manager orders for this blueprint.) build remaining doors +doors/farming_doors +#zone label(farming_zone) start(16; 18) hidden() rooms + + +,,,,,,,,,T{pets=true}(1x1),`,`,,`,`,`,`,`,,"h{name=""Starter dining hall""}(4x6)",,,` +,,,,,,,,,T{pets=true}(1x1),`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,,,T{pets=true}(1x1),`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,,,,,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,"o{name=""Manager's office"" assigned_unit=manager}(3x1)",,`,,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,`,`,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,"o{name=""Bookkeeper's office"" assigned_unit=bookkeeper}(3x1)",,`,,`,,`,`,`,`,`,,` +,,,,,,,,,,,`,,`,`,`,`,`,,`,,"D{name=""Starter dormitory""}(3x3)",,` +,,,,,,`,`,`,`,,`,,`,`,`,`,`,,`,`,`,`,` +,,,,,,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,` +,,,`,`,,`,`,`,`,,`,,`,`,`,`,`,,` +,,`,`,`,,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,,`,`,` +,,`,`,`,`,`,`,`,`,`,`,,,`,,`,,,`,`,`,`,`,`,`,`,` +,,,`,`,,`,`,`,`,,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,` +,,,,`,,,`,,,,,,`,`,`,`,`,,,,,`,,,,` +,,`,`,`,`,`,`,`,`,`,`,,`,`,~,`,`,,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,,,,`,,`,,,,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,,`,`,,,`,,,`,`,,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,,`,`,`,,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,,`,,,`,`,`,,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,` + + +"#place label(farming_place) start(16; 18) hidden() message(remember to assign a minecart to the refuse quantum stockpile (run ""assign-minecarts all"")" + + +,,,,,,,,,`,`,`,,`,`,`,"c{name=""Seeds"" barrels=10 links_only=true take_from=""Starting food""}:+seeds(1x9)","c{name=""Potash""}:+potash(1x12)",,"c{name=""Booze"" barrels=-1 take_from=""Starting food""}:+booze(4x2)",,,` +,,,,,,,,,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,,,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,,,,,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,`,`,`,,`,,`,`,`,`,`,,`,"c{name=""Prepared food"" take_from=""Starting food""}:+preparedmeals(3x2)",,` +,,,,,,,`,`,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,`,`,`,,`,,`,`,`,`,`,,` +,,,,,,,,,,,`,,`,`,`,`,`,,`,,`,`,` +,,,,,,`,`,`,"u{name=""Pots"" take_from=""Starting misc""}:-cat_furniture/type+pots(1x4)",,`,,`,`,`,`,`,,`,`,`,`,` +,,,,,,`,`,`,~,,`,,"c{name=""Seeds feeder"" give_to=""Seeds"" take_from=""Starting food""}:+seeds(4x3)",,,,`,,`,,`,`,` +,,,"u{name=""Bags"" take_from=""Starting misc""}:-cat_furniture/type+bags(2x2)",~,,`,`,`,~,,`,,`,`,`,`,`,,` +,,`,~,~,,`,`,`,~,,`,,`,`,`,`,`,,`,,`,`,`,,`,`,` +,,`,"c{name=""Jugs"" take_from=""Starting misc"" give_to=""Cookable food""}:+cat_finished_goods/core,total+woodtools(2x2)",~,`,`,`,`,"u{name=""Barrels"" take_from=""Starting misc,Starting food""}:-cat_furniture/type+barrels(1x2)",`,`,,,`,,`,,,`,`,`,`,`,`,`,`,` +,,,~,~,,`,`,`,~,,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,` +,,,,`,,,`,,,,,,`,`,`,`,`,,,,,`,,,,` +,,"c{name=""Plants"" barrels=-1 take_from=""Starting food""}:+plants",c,c,c,c,c,c,c,c,c,,`,`,~,`,`,,"c{name=""Cookable food"" barrels=-1 take_from=""Starting food""}:+cat_food/meat/,fish/prepared/,egg/,cheese/,leaves/,powder/,glob/,liquid/plant/,paste/,pressed/,milk,royal_jelly-dye-cat_food/tallow,thread,liquid/misc/",c,c,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,c,c,c,`,`,`,`,`,`,`,c,c,c,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,c,c,c,,`,`,`,`,`,,c,c,c,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,c,c,,,,`,,`,,,,c,c,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,c,,,c,`,`,`,`,`,c,,,c,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,c,,"c{name=""Unprepared fish"" take_from=""Starting food""}:+unpreparedfish",c,,,`,,,"c{name=""Rawhides"" take_from=""Starting cloth/trash""}:+rawhides",c,,c,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,,,c,c,,"c{name=""Refuse feeder"" give_to=""Rawhides"" take_from=""Starting cloth/trash""}:+cat_refuse/type(1x3)","y2{name=""Corpse feeder"" take_from=""Starting cloth/trash""}:+cat_refuse/corpses,bodyparts(2x3)",~,,c,c,,,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,,`,`,`,,~,~,~,,`,`,`,,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,,`,`,`,,~,~,~,,`,`,`,,c,c,c,c,c,c,c +,,c,c,c,c,c,c,c,,`,`,`,,,`,,,`,`,`,,c,c,c,c,c,c,c +,,,,,,,,,,,,,,,"ry{name=""Refuse/corpse quantum"" give_to=""Rawhides"" quantum=true}" + + +#build label(farming_build) start(16; 18) hidden() workshops and important furniture + + +,,,,,,,,,n,`,`,,p(3x1),,,`,`,,`,`,`,` +,,,,,,,,,n,`,`,,p(3x1),,,`,`,,`,`,`,` +,,,,,,,,,n,`,`,,p(3x1),,,`,`,,c,t,t,c +,,,,,,,,,,,`,,p(3x1),,,`,`,,c,t,t,c +,,,,,,,t,c,`,,`,,p(3x1),,,`,`,,`,`,`,` +,,,,,,,`,`,`,`,`,,p(3x1),,,`,`,,`,`,`,` +,,,,,,,t,c,`,,`,,p(3x1),,,`,`,,` +,,,,,,,,,,,`,,p(3x1),,,`,`,,`,,b{do_now=true},b{do_now=true},b +,,,,,,`,`,`,`,,`,,p(3x1),,,`,`,,`,`,`,`,h +,,,,,,`,wl,`,`,,`,,`,`,`,`,`,,`,,b,b,b +,,,`,`,,`,`,`,`,,`,,`,`,`,`,`,,` +,,wq,`,`,,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,,`,`,` +,,wp,`,`,`,`,"ww{labor_mask=""Milking, Shearing""}",`,`,`,`,,,`,,`,,,`,`,`,wu,`,`,`,wz,` +,,,`,`,,`,`,`,`,,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,` +,,,,`,,,`,,,,,,`,`,`,`,`,,,,,`,,,,` +,,`,`,`,`,`,`,`,`,`,`,,`,`,~,`,`,,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,,,,`,,`,,,,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,,,`,d,`,`,`,d,`,,,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,,`,`,,,d,,,`,`,,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,,`,`,`,,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,wh,`,,`,`,`,,`,wn,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,,"trackstopS{name=""Refuse/corpse dumper"" take_from=""Refuse feeder,Corpse feeder"" route=""Refuse/corpse quantum""}",,,`,`,`,,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,` + + +#dig label(farming_traffic) start(16; 18) hidden() keep hungry dwarves away from the crops and food stores so they prefer the prepared meals + + +,,,,,,,,,ol,ol,ol,,or,or,or,or,or,,ol,ol,ol,ol +,,,,,,,,,ol,ol,ol,,or,or,or,or,or,,ol,ol,ol,ol +,,,,,,,,,ol,ol,ol,,or,or,or,or,or,,ol,ol,ol,ol +,,,,,,,,,,,ol,,or,or,or,or,or,,ol,ol,ol,ol +,,,,,,,ol,ol,ol,,ol,,or,or,or,or,or,,ol,ol,ol,ol +,,,,,,,ol,ol,ol,ol,ol,,or,or,or,or,or,,ol,ol,ol,ol +,,,,,,,ol,ol,ol,,ol,,or,or,or,or,or,,ol +,,,,,,,,,,,ol,,or,or,or,or,or,,ol,,ol,ol,ol +,,,,,,ol,ol,ol,ol,,ol,,or,or,or,or,or,,ol,ol,ol,ol,ol +,,,,,,ol,ol,ol,ol,,ol,,or,or,or,or,or,,ol,,ol,ol,ol +,,,ol,ol,,ol,ol,ol,ol,,ol,,or,or,or,or,or,,ol +,,ol,ol,ol,,ol,ol,ol,ol,,ol,,or,or,or,or,or,,ol,,or,or,or,,or,or,or +,,ol,ol,ol,ol,ol,ol,ol,ol,ol,ol,,,or,,or,,,ol,or,or,or,or,ol,or,or,or +,,,ol,ol,,ol,ol,ol,ol,,ol,ol,ol,ol,ol,ol,ol,ol,ol,,or,or,or,,or,or,or +,,,,or,,,or,,,,,,ol,`,`,`,ol,,,,,or,,,,or +,,or,or,or,or,or,or,or,or,or,or,,ol,`,~,`,ol,,or,or,or,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,or,or,or,or,ol,`,`,`,ol,or,or,or,or,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,or,or,or,,ol,ol,ol,ol,ol,,or,or,or,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,or,or,,,,or,,or,,,,or,or,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,or,,,or,or,or,or,or,or,or,,,or,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,or,,or,or,,,or,,,or,or,,or,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,,,or,or,,or,or,or,,or,or,,,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,,or,or,or,,or,or,or,,or,or,or,,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,,or,or,or,,or,or,or,,or,or,or,,or,or,or,or,or,or,or +,,or,or,or,or,or,or,or,,or,or,or,,,or,,,or,or,or,,or,or,or,or,or,or,or +,,,,,,,,,,,,,,,or + + +#burrow label(farming_burrow) start(16; 18) hidden() fix up safety burrow after channel incursions + +,,,,,,,,a{name=Inside+}(16x4) +,,,,,,,,,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,,,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,,,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,a{name=Inside+}(18x3),,,,,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,`,`,`,,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,`,`,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,a{name=Inside+}(19x1),`,`,`,,`,,`,`,`,`,`,,` +,,,,,a{name=Inside+}(20x2),,,,,,`,,`,`,`,`,`,,`,,`,`,` +,,,,,,`,`,`,`,,`,,`,`,`,`,`,,`,`,`,`,` +,,a{name=Inside+}(23x1),,,,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,` +,a{name=Inside+}(28x4),,`,`,,`,`,`,`,,`,,`,`,`,`,`,,` +,,`,`,`,,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,,`,`,` +,,`,`,`,`,`,`,`,`,`,`,,,`,,`,,,`,`,`,`,`,`,`,`,` +,,,`,`,,`,`,`,`,,`,`,`,`,`,`,`,`,`,,`,`,`,,`,`,` +,a{name=Inside+}(29x12),,,`,,,`,,,,,,`,`,`,`,`,,,,,`,,,,` +,,`,`,`,`,`,`,`,`,`,`,,`,`,~,`,`,,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,,,,`,,`,,,,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,,`,`,,,`,,,`,`,,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,,`,`,`,,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,,`,,,`,`,`,,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,a{name=Inside+}(3x1) + +#build label(farming_doors) start(16; 18) hidden() remaining doors + + +,,,,,,,,,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,,,`,`,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,,,`,`,`,,`,`,`,`,`,,~,~,~,~ +,,,,,,,,,,,d,,`,`,`,`,`,,~,~,~,~ +,,,,,,,`,`,`,,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,`,`,`,d,`,,`,`,`,`,`,,`,`,`,` +,,,,,,,`,`,`,,`,,`,`,`,`,`,,d +,,,,,,,,,,,`,,`,`,`,`,`,,`,,~,~,~ +,,,,,,`,`,`,`,,`,,`,`,`,`,`,,`,d,`,`,~ +,,,,,,`,`,`,`,,`,,`,`,`,`,`,,`,,~,~,~ +,,,`,`,,`,`,`,`,,`,,`,`,`,`,`,,` +,,`,`,`,,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,,`,`,` +,,`,`,`,d,`,`,`,`,d,`,,,d{name=Farming},,d{name=Farming},,,`,d,`,`,`,d,`,`,` +,,,`,`,,`,`,`,`,,`,d{name=Farming},`,`,`,`,`,d{name=Farming},`,,`,`,`,,`,`,` +,,,,d,,,d,,,,,,`,`,`,`,`,,,,,d,,,,d +,,`,`,`,`,`,`,`,`,`,`,,`,`,~,`,`,,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,d{name=Farming},`,`,`,`,`,d{name=Farming},`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,,,,d{name=Farming},,d{name=Farming},,,,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,,,`,~,`,`,`,~,`,,,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,,`,`,,,~,,,`,`,,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,,`,`,`,,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,`,`,,,`,,,`,`,`,,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,` + + +#notes label(industry_help) industry level walkthrough +Sets up workshops for all non-farming industries +Screenshot: https://drive.google.com/file/d/1c8YTHxTgJY5tUII-BOWdLhmDFAHwIOEs +"" +Features: +- Compact layout that covers all workshops +- Manager orders that automate basic fortress maintenance +"- Space available underneath the forge and smelters for magma, allowing the starting forge and smelters to be eventually replaced by magma versions." +- Quantum stockpiles for compact storage (see the wiki for more info on QSPs) +with separate stockpiles for: +- A reserve of uncut gems for strange moods that the jeweler's workshop cannot take from +"- Wood, iron bars, steel bars, flux, and coal so you can see at a glance if you're low on stock" +"- Items that cannot be quantum stockpiled (e.g. lye, dye, and sand bags)" +- Meltable weapons and armor +"" +Workshops: +- 2x Stoneworker +- 4x Craftsdwarf (labor restrictions set to specialize for materials in adjacent stockpiles) +- 1x Jeweler +- 1x Mechanic +- 4x Smelter +- 1x Forge +- 1x Glassmaker +- 1x Kiln +- 4x Wood furnace +- 1x Ashery +- 1x Soap maker +- 1x Carpenter +- 1x Siege workshop +- 1x Bowyer +- 1x Dyer +- 1x Loom +- 1x Clothier +"" +Manual steps you have to take: +- Assign minecarts to your quantum stockpile hauling routes. The assign-minecarts all command will do it for you. +"" +Optional manual steps you can take: +"- If desired, set one or both stockpiles in the bottom left to auto-melt. This results in melting all weapons and armor that are inferior to masterwork. This is great for upgrading your military, but it takes a *lot* of fuel unless you have first replaced the forge and smelters with magma versions. If you enable automelt and you don't have magma forges and magma smelters, be sure to be in a forested area, set up autochop, and keep your coal stocks high!" +"" +Industry Walkthrough: +"1) Start digging out /industry1 as soon as you find a non-aquifer stone layer at least two layers beneath the surface so the boulders can be used by your starting workshops. The services level is intended to be dug beneath this one, and there is space on that level to route magma underneath your furnaces so you can replace the furnaces on this level with magma-powered equivalents." +"" +"2) Generate manager orders for /industry2 if you haven't already preordered with the checklist command. You brought an anvil with you (right??), so you can remove the unneeded anvil work order from the manager orders screen. Note that stockpiles that accept containers may claim the barrels you need to build the Dyer's Workshop and Ashery. If you see those two buildings not being constructed, build a few extra barrels or run combine all to free up some existing ones." +"" +"3) Once the area is dug out, run /industry2 to build replacements for your starter workshops up on the surface. Remember to assign minecarts to to your quantum stockpile hauling routes with assign-minecarts all." +"" +"4) After the initial workshops are constructed, run /industry3 to build the remaining workshops. Generate manager orders if you haven't already preordered with the checklist command." +"" +"5) Once you have enough dwarves to do maintenance tasks (that is, after the first or second migration wave), run ""orders import library/basic"" to use the provided manager orders to take care of your fort's basic needs, such as food, booze, and raw material processing." +"" +"6) If you want to automatically melt goblinite and other non-masterwork weapons and armor, mark the south-west stockpiles for auto-melt. If you don't have an abundance of fuel, though, be sure to route magma to the level beneath this one and replace the forge and furnaces with magma equivalents." +"" +"7) Once you have magma furnaces (or abundant fuel) and more dwarves, run ""orders import library/furnace"", ""orders import library/military"", and ""orders import library/smelting"" (in that order) to import the remaining fort automation orders. The military orders are optional if you are not planning to have a military, of course." +"" +"8) At any time, feel free to build extra workshops or designate custom stockpiles in the remaining open space. The space is there for you to use! Note the area in the bottom right can be used for additional magma-powered furnaces and workshops since there is space reserved for magma in those spots in the services level beneath." +"#dig label(industry1) start(18; 18; central stairs) message(Once the area is dug out, continue with /industry2.)" + + +,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,,,d,,d,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,,d,`,`,`,d,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,,,d,,d,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d + + +"#meta label(industry2) start(central stairs) message(If you preordered items on the checklist, good. If not, don't forget to generate orders for this blueprint now.) stockpiles and high-priority workshops" +traffic/industry_traffic +place/industry_place +build/industry_build +"#meta label(industry3) start(central stairs) message(If you preordered items on the checklist, good. If not, don't forget to generate orders for this blueprint now.) remaining workshops" +build2/industry_build2 +#dig label(industry_traffic) start(18; 18; central stairs) hidden() traffic patterns + + +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,oh,ol,ol,ol,oh,ol,ol,ol,oh,ol,ol,ol,oh +,,,,oh,oh,oh,oh,oh,oh,oh,oh,ol,ol,ol,oh,ol,ol,ol,oh,ol,ol,ol,oh,oh,oh,oh,oh,oh,oh,oh +,,,,oh,ol,ol,ol,ol,ol,ol,oh,ol,ol,ol,oh,ol,ol,ol,oh,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,oh,ol,ol,ol,ol,ol,ol,oh,ol,ol,ol,oh,oh,oh,oh,oh,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,oh,ol,ol,ol,ol,ol,ol,oh,ol,ol,ol,oh,oh,`,oh,oh,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,oh,ol,ol,ol,ol,ol,ol,oh,ol,ol,ol,oh,oh,`,oh,oh,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,oh,ol,ol,ol,ol,ol,ol,oh,ol,ol,ol,`,`,`,`,`,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,oh,ol,ol,ol,ol,ol,ol,oh,ol,ol,ol,`,`,`,`,`,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,`,oh,oh,oh,oh,oh,oh,oh,oh,oh,ol,ol,ol,`,`,`,`,`,ol,ol,ol,oh,oh,oh,oh,oh,oh,oh,oh,oh,` +,,`,ol,ol,ol,ol,ol,ol,ol,ol,ol,oh,oh,oh,`,`,`,`,`,oh,oh,oh,ol,ol,ol,ol,ol,ol,ol,ol,ol,` +,,`,ol,ol,ol,ol,ol,ol,ol,ol,ol,oh,oh,oh,`,`,`,`,`,oh,oh,oh,ol,ol,ol,ol,ol,ol,ol,ol,ol,` +,,`,ol,ol,ol,ol,ol,ol,ol,ol,ol,oh,oh,,,`,,`,,,oh,oh,ol,ol,ol,ol,ol,ol,ol,ol,ol,` +,,`,oh,oh,oh,oh,oh,oh,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,oh,oh,oh,oh,oh,oh,` +,,`,ol,ol,ol,oh,oh,oh,`,`,`,`,`,`,`,,,,`,`,`,`,`,`,`,oh,oh,oh,ol,ol,ol,` +,,`,ol,ol,ol,oh,`,`,`,`,`,`,`,,`,,`,,`,,`,`,`,`,`,`,`,oh,ol,ol,ol,` +,,`,ol,ol,ol,oh,oh,oh,`,`,`,`,`,`,`,,,,`,`,`,`,`,`,`,oh,oh,oh,ol,ol,ol,` +,,`,oh,oh,oh,oh,oh,oh,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,oh,oh,oh,oh,oh,oh,` +,,`,ol,ol,ol,ol,ol,ol,ol,ol,ol,oh,oh,,,`,,`,,,oh,oh,ol,ol,ol,ol,ol,ol,ol,ol,ol,` +,,`,ol,ol,ol,ol,ol,ol,ol,ol,ol,oh,oh,oh,`,`,`,`,`,oh,oh,oh,ol,ol,ol,ol,ol,ol,ol,ol,ol,` +,,`,ol,ol,ol,ol,ol,ol,ol,ol,ol,oh,oh,oh,`,`,`,`,`,oh,oh,oh,ol,ol,ol,ol,ol,ol,ol,ol,ol,` +,,`,oh,oh,oh,oh,oh,oh,oh,oh,oh,ol,ol,ol,`,`,`,`,`,ol,ol,ol,oh,oh,oh,oh,oh,oh,oh,oh,oh,` +,,,,`,`,`,`,`,`,`,oh,ol,ol,ol,`,`,`,`,`,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,`,`,`,`,`,`,`,oh,ol,ol,ol,`,`,`,`,`,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,`,`,`,`,`,`,`,oh,ol,ol,ol,oh,oh,`,oh,oh,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,oh,oh,oh,oh,oh,oh,oh,oh,ol,ol,ol,`,oh,`,oh,`,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,`,`,`,`,`,`,`,oh,ol,ol,ol,`,`,`,`,`,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,`,`,`,`,`,`,`,oh,ol,ol,ol,`,ol,ol,ol,`,ol,ol,ol,oh,ol,ol,ol,ol,ol,ol,oh +,,,,`,`,`,`,`,`,`,oh,ol,ol,ol,`,ol,ol,ol,`,ol,ol,ol,oh,oh,oh,oh,oh,oh,oh,oh +,,,,,,,,,,,oh,ol,ol,ol,oh,ol,ol,ol,oh,ol,ol,ol,oh +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` + + +"#place label(industry_place) start(18; 18) hidden() message(remember to: +- assign minecarts to to your quantum stockpile hauling routes (use ""assign-minecarts all"") +- if you want to automatically melt goblinite and other low-quality weapons and armor, mark the south-east stockpiles for auto-melt +- once you have enough dwarves, run ""orders import library/basic"" to automate your fort's basic needs (see /industry_help for more info on this file)) industry stockpiles" + + +,,,,,,,,,,,"e{name=""Rough gems for moods"" containers=0 take_from=""Stoneworker quantum,Gem feeder""}:=roughgems",e,e,e,e,e,e,e,e,e,e,e,e +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,"se{name=""Stoneworker quantum"" quantum=true}",`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,"s10{name=""Stone feeder""}:=otherstone(5x4)",,,~,~,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,` +,,"w{name=""Wood"" take_from=""Goods/wood quantum,Wood feeder""}",`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,`,`,"c{name=""Dye"" barrels=-1 }:+dye" +,,w,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,`,`,c +,,w,`,`,`,`,`,`,`,`,`,`,`,`,"e{name=""Gem feeder"" containers=0}(5x1)",,,~,~,`,`,`,`,`,`,`,`,`,`,`,`,c +,,w,`,`,`,`,`,`,`,`,`,`,`,,,`,,`,,,`,`,`,`,`,`,`,`,`,`,`,c +,,w,`,`,`,`,`,`,"w{name=""Wood feeder""}(2x5)",,"g{name=""Goods feeder"" containers=0}:+cat_food/tallow+wax-crafts-goblets(3x3)",,`,,`,`,`,`,`,,"hlS{name=""Cloth/bones feeder"" containers=0}:+cat_refuse/skulls/,bones/,hair/,shells/,teeth/,horns/-adamantinethread(5x5)",,,~,~,`,`,`,`,`,`,c +,,w,`,`,`,`,`,`,~,~,~,~,~,`,`,,,,`,`,~,~,~,~,~,`,`,`,`,`,`,c +,,`,`,`,`,`,"c{name=""Goods/wood quantum"" quantum=true give_to=""Pots,Barrels,Jugs,Bags,Seeds feeder""}:+all-cat_animals",`,~,~,~,~,~,,`,,`,,`,,~,~,~,~,~,`,"r{name=""Cloth/bones quantum"" quantum=true}:+all",`,`,`,`,c +,,"c{name=""Lye"" barrels=0}:+miscliquid",`,`,`,`,`,`,~,~,"u2{name=""Furniture feeder""}:-sand(3x2)",~,~,`,`,,,,`,`,~,~,~,~,~,`,`,`,`,`,`,c +,,c,`,`,`,`,`,`,~,~,~,~,~,,`,`,`,`,`,,~,~,~,~,~,`,`,`,`,`,`,c +,,c,`,`,`,`,`,`,`,`,`,`,`,,,`,,`,,,`,`,`,`,`,`,`,`,`,`,`,c +,,c,`,`,`,`,`,`,`,`,`,`,`,`,"bnpdz{name=""Bar/military feeder"" containers=0}:-potash+adamantinethread(5x3)",,,,~,`,`,`,`,`,`,`,`,`,`,`,`,c +,,c,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,`,`,c +,,c,`,`,`,`,`,`,`,`,`,`,`,`,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,`,`,c +,,,,"pd{name=""Meltable steel/bronze"" take_from=""Metalworker quantum,Bar/military feeder"" containers=0}:-cat_weapons/mats/,other/-cat_armor/mats/,other/+bronzeweapons+bronzearmor+steelweapons+steelarmor-masterworks-artifacts(7x3)",,,~,~,~,~,`,`,`,`,"s5{name=""Ore/clay feeder""}:-otherstone(5x2)",,,~,~,`,`,`,`,`,`,`,`,`,`,` +,,,,~,~,~,~,~,~,~,`,`,`,`,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,` +,,,,~,~,~,~,~,~,~,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,"c{name=""Coal"" containers=0 take_from=""Metalworker quantum,Bar/military feeder""}:+coal",`,"c{name=""Metalworker quantum"" quantum=true}:+all",`,"c{name=""Iron"" containers=0 take_from=""Metalworker quantum,Bar/military feeder""}:+ironbars",`,`,`,`,`,`,`,`,`,`,` +,,,,"pd{name=""Other meltables"" take_from=""Metalworker quantum,Bar/military feeder"" containers=0}:-cat_weapons/other/-cat_armor/other/-bronzeweapons-bronzearmor-steelweapons-steelarmor-masterworks-artifacts(7x3)",,,~,~,~,~,`,`,`,`,c,"c{name=Flux take_from=""Metalworker quantum,Ore/clay feeder"" links_only=true}:+flux(3x1)",,,c,`,`,`,`,`,`,`,`,`,`,` +,,,,~,~,~,~,~,~,~,`,`,`,`,c,`,`,`,c,`,`,`,`,`,`,`,`,`,`,` +,,,,~,~,~,~,~,~,~,`,`,`,`,c,`,`,`,c,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,"u{name=""Sand bags""}:-cat_furniture/type+sand",u,u,u,u,u,`,"c{name=""Steel"" containers=0 take_from=""Metalworker quantum,Bar/military feeder""}:+steelbars",c,c,c,c,c + + +#build label(industry_build) start(18; 18) hidden() workshops to build first + + +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,"wj{name=""Encruster"" do_now=true take_from=""Goods/wood quantum,Stoneworker quantum,Gem feeder""}",`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,"wr{name=""Stone craftsdwarf"" do_now=true labor=Stonecrafting}",`,`,`,`,`,`,`,wt{do_now=true},`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,"trackstopN{name=""Stone/gem dumper"" do_now=true take_from=""Stone feeder,Gem feeder"" route=""Stone/gem quantum""}",`,`,`,`,`,`,`,`,~,`,`,`,` +,,,,`,`,~,`,`,~,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,wm{max_general_orders=2 do_now=true},`,`,`,`,`,`,`,wm{max_general_orders=10 do_now=true},`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,~,`,`,~,`,`,~,`,`,`,`,`,`,`,`,`,`,`,`,`,~,`,`,~,`,`,~,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,,,~,,~,,,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,~,`,,,,`,~,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,wc{max_general_orders=9 do_now=true},`,`,`,"trackstopW{name=""Goods/wood dumper"" do_now=true take_from=""Wood feeder,Goods feeder,Furniture feeder"" route=""Goods/wood quantum""}",`,`,`,`,`,,`,,`,,`,,`,`,`,`,`,"trackstopE{name=""Cloth/bones dumper"" do_now=true take_from=""Cloth/bones feeder"" route=""Cloth/bones quantum""}",`,`,`,~,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,~,`,,,,`,~,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,,,~,,~,,,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,~,`,`,~,`,`,~,`,`,`,`,`,`,`,`,`,`,`,`,`,~,`,`,~,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,"trackstopS{name=""Metalworker dumper"" do_now=true take_from=""Bar/military feeder,Ore/clay feeder"" route=""Metalworker quantum""}",`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,~,`,`,`,~,`,`,`,~,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` + + +#build label(industry_build2) start(18; 18) hidden() remaining workshops + + +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,`,ws,`,`,`,` +,,,,`,`,wS,`,`,wb,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,wy,`,`,ew,`,`,ew,`,`,`,`,`,`,`,`,`,`,`,`,`,wk,`,`,wo,`,`,"wd{take_from=""Cloth/bones feeder,Cloth/bones quantum,Dye""}",`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,,,d{name=Industry},,d{name=Industry},,,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,d{name=Industry},`,,,,`,d{name=Industry},`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,~,`,`,`,~,`,`,`,`,`,,`,,`,,`,,`,`,`,`,`,~,`,`,`,we,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,d{name=Industry},`,,,,`,d{name=Industry},`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,,,d{name=Industry},,d{name=Industry},,,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,"wr{name=""Wood craftsdwarf"" labor=Woodcrafting}",`,`,ew,`,`,ew,`,`,`,`,`,`,`,`,`,`,`,`,`,"wr{name=""Misc craftsdwarf"" labor_mask=""Stonecrafting,Woodcrafting,Bone Carving""}",`,`,"wr{name=""Bone craftsdwarf"" labor=""Bone Carving""}",`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,es,`,`,`,`,`,`,`,es,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,~,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,es,`,`,`,`,`,`,`,es,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,`,`,`,`,`,`,`,eg,`,`,`,wf{max_general_orders=9},`,`,`,ek,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,` + + +#notes label(services_help) services level walkthrough +"Sets up public services (dining, hospital, etc.)" +Screenshot: https://drive.google.com/file/d/1RQMy_zYQWM5GN7-zjn6LoLWmnrJjkxPM +"" +Features: +- Spacious dining room/tavern (tavern is restricted to citizens and residents only by default) +- Large prepared food and drink stockpiles +- Well cistern system (route or carry your own water) +- Hospital (also restricted to residents by default) with a well and soap for washing +- Well-appointed jail cells for happy prisoners +- Bolt-recycling archery range for your marksdwarves +- Interrogation room (office) for your Captain of the Guard +- Garbage dump +- Empty space for magma to power forges and smelters in the industry level above +"" +Manual steps you have to take: +"- If you want to tavern to attract visitors, change the restriction in the location configuration screen." +"- Fill the cisterns with water, either with a bucket brigade or by plumbing flowing water (e.g. with the aquifer_tap library blueprint). Fill so that there are two z-levels of 7-depth water to prevent muddiness. If you want to fill with buckets, you can use the pre-designated pond zones on the level below the main floor. If you feel adventurous and are experienced with water pressure, you can instead route (depressurized!) water to the second-to-bottom level (the one above the up staircases). See the aquifer_tap blueprint for help with getting water from a light aquifer." +"- If you are filling the wells with a bucket brigade and at least one well is already constructed, you'll run into issues with the dwarves stealing water from one well to fill another. Temporarily deconstruct the wells or temporarily build grates beneath the wells to block the buckets to avoid this issue. Remember to rebuild the wells or remove the grates afterwards, though!" +"" +Services Walkthrough: +1) Start this level when your fort grows to about 30 dwarves so everyone has a place to eat. +"" +2) Start digging with /services1. Note that this digs out the main level and three levels below for the well cisterns. +"" +"3) Once the area is dug out, start populating the rooms with /services2. Generate manager orders for /services2." +"" +"4) Fill the wells with either bucket brigades or by carefully routing flowing water (you can use the ""blueprinted"" plumbing template or erase it and plan your own). If you are using a bucket brigade, you have to activate the ""Cistern"" pond zones (which you can search for in the Places screen)." +"" +"5) When your fort has grown some more, or you start needing a jail, run /services3 to extend the rooms a bit more. Generate manager orders for /services3." +"" +"6) When your fort is more mature and you need to expand the rooms, run /services4 to finish everything up. If you didn't have a Sheriff/Captain of the Guard to automatically assign to the interrogation room when you ran /services2, you can manually assign the office now. Generate manager orders for /services4." +"#dig label(services1) start(18; 18; central stairs) message(Once the area is dug out, continue with /services2.)" + +,d,d,d,,d,d,d,,d,d,d,,d,h,d,,d,h,d,,d,h,d,,d,h,d,,d,h,d +,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d +,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d,,d,d,d +,,d,,,,d,,,,d,,,,d,,,,d,,,,d,,,,d,,,,d +,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,,,,,d +,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,,d,,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,h5,h5,h5,h5,h5,h5,h5,h5,h5,h5,d,,d,,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,h,h,h,h,h,h,h,h,h,h,d,,d,,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,d,d,d,d,d,d,d,d,,j,,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,d,d,d,d,d,d,d,d,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,,,,,d,,d,,,,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,,,,d,d,d,d,d,,,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,d,,d,`,`,`,d,,d,,d,d,d,d,d,d,d,d,d,h +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,,,,d,d,d,d,d,,,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,,,,,,d,,,,,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d +,,,,d,d,,d,d +,d,d,d,d,d,,d,d,d,d,d +,d,d,d,d,d,,d,d,d,d,d +,d,d,d,d,d,,d,d,d,d,d +,d,d,d,d,d,,d,d,d,d,d +,d,d,d,d,d,,d,d,d,d,d + +#> + +,,,,,,,,,,,,,j5,h5,j,,j5,h5,j,,j5,h5,j,,j5,h5,j,,j5,h5,j +,,,,,,,,,,,,,5,5,5,,5,5,5,,5,5,5,,5,5,5,,5,5,5 +,,,,,,,,,,,,,,d,,,,d,,,,d,,,,d,,,,d +,,,,,,,,,,,,,,d,,,,d,,,,d,,,,d,,,,d +,,,,,,,,,,,,,,d,,,,d,,,,d,,,,d,,,,d +,,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,,,,d +,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,,,u,d +,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,d,d,d,d,d,,,,,,,d +,,,,,,,,,,,,,,,d,`,`,`,d,,,,,,,d,,,,,5,j5 +,,,,,,,,,,,,,,,d,`,`,`,d,,,,,,,d,d,d,d,d,5,h5 +,,,,,,,,,,,,,,,d,`,`,`,d,,,,,,,,,,,,5,j +,,,,,,,,,,,,,,,d,d,d,d,d + +#> + +,,,,,,,,,,,,,u5,h5,i,,u5,h5,i,,u5,h5,i,,u5,h5,i,,u5,h5,i +,,,,,,,,mbd,,,,,,mbd,,,,mbd,,,,mbd,,,,mbd,,,,mbd +,,,,,,,mbd,,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd,mbd +,,,,,,,,mbd,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,d,d,d,d,d,,,,,,,,,,,mbd +,,,,,,,,,,,,,,,d,`,`,`,d,,,,,,,,,,,mbd,,u5 +,,,,,,,,,,,,,,,d,`,`,`,d,,,,,,,,,,,mbd,mbd,h5 +,,,,,,,,,,,,,,,d,`,`,`,d,,,,,,,,,,,,,i +,,,,,,,,,,,,,,,d,d,d,d,d + +#> + +,,,,,,,,,,,,,,d,u,,,d,u,,,d,u,,,d,u,,,d,u + + + + + + + + + + + + + +,,,,,,,,,,,,,,,d,d,d,d,d +,,,,,,,,,,,,,,,d,`,`,`,d +,,,,,,,,,,,,,,,d,`,`,`,d,,,,,,,,,,,,,d +,,,,,,,,,,,,,,,d,`,`,`,d,,,,,,,,,,,,,u +,,,,,,,,,,,,,,,d,d,d,d,d + +"#meta label(services2) start(central stairs) message(Once furniture has been built, continue with /services3.) zones and minimally functional hospital and dining hall" +traffic/services_traffic +zones/services_zones +place/services_place +build/services_build +smooth/services_smooth +"" +"#meta label(services3) start(central stairs) message(Once furniture has been built, continue with /services4.) expand furnishings" +place2/services_place2 +build2/services_build2 +smooth2/services_smooth2 +"" +#meta label(services4) start(central stairs) complete furnishings +place3/services_place3 +build3/services_build3 +#dig label(services_traffic) start(18; 18) hidden() keep lollygaggers out of the cisterns and justice areas + +,`,`,`,,`,`,`,,`,`,`,,or,or,or,,or,or,or,,or,or,or,,or,or,or,,or,or,or +,`,`,`,,`,`,`,,`,`,`,,or,or,or,,or,or,or,,or,or,or,,or,or,or,,or,or,or +,`,`,`,,`,`,`,,`,`,`,,or,or,or,,or,or,or,,or,or,or,,or,or,or,,or,or,or +,,`,,,,`,,,,`,,,,or,,,,or,,,,or,,,,or,,,,or +,`,`,`,`,`,`,`,`,`,`,`,,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,or +,`,`,`,`,`,`,`,`,`,`,`,,or,or,or,or,or,or,or,or,or,or,or,,or,,or,or,or,or,or +,`,`,`,`,`,`,`,`,`,`,`,,or,or,or,or,or,or,or,or,or,or,or,,or,,or,or,or,or,or +,`,`,`,`,`,`,`,`,`,`,`,,or,or,or,or,or,or,or,or,or,or,or,,or,,or,or,or,or,or +,`,`,`,`,`,`,`,`,`,`,`,,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or +,`,`,`,`,`,`,`,`,`,`,`,,or,or,or,or,or,or,or,or,or,or,or,,or,,or,or,or,or,or +,`,`,`,`,`,`,`,`,`,`,`,,or,or,or,or,or,or,or,or,or +,`,`,`,`,`,`,`,`,`,`,`,,or,or,or,or,or,or,or,or,or,,or,,or,,or,,or,,or +,`,`,`,`,`,`,`,`,`,`,`,,,,,or,,or,,,,,or,,or,,or,,or,,or +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,or,,or,,or,,or,,or +,`,ol,ol,ol,oh,oh,oh,ol,ol,ol,`,`,`,`,`,`,`,`,`,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh +,`,or,or,ol,oh,or,oh,ol,or,or,`,,`,,`,`,`,`,`,,`,,oh,oh,oh,oh,oh,oh,oh,oh,oh,or +,`,or,or,ol,oh,oh,oh,ol,or,or,`,`,`,`,`,`,`,`,`,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh +,`,or,or,or,ol,oh,ol,or,or,or,`,,,,`,`,`,`,`,,,,or,,or,,or,,or,,or +,`,or,or,or,or,oh,or,or,or,or,`,,,,,,or,,,,,,or,,or,,or,,or,,or +,`,or,or,or,or,oh,or,or,or,or,`,,,,,,,,,,,,or,,or,,or,,or,,or +,`,or,or,or,or,oh,or,or,or,or,` +,`,or,or,or,or,oh,or,or,or,or,` +,`,or,or,or,or,oh,or,or,or,or,` +,`,or,or,or,or,oh,or,or,or,or,` +,`,`,`,oh,oh,oh,oh,oh,`,`,` +,`,`,`,oh,oh,`,oh,oh,`,`,` +,,,,oh,oh,,oh,oh +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` + +#> + +,,,,,,,,,,,,,or,or,or,,or,or,or,,or,or,or,,or,or,or,,or,or,or +,,,,,,,,,,,,,or,or,or,,or,or,or,,or,or,or,,or,or,or,,or,or,or +,,,,,,,,,,,,,,or,,,,or,,,,or,,,,or,,,,or +,,,,,,,,,,,,,,or,,,,or,,,,or,,,,or,,,,or +,,,,,,,,,,,,,,or,,,,or,,,,or,,,,or,,,,or +,,,,,,,,,,,,,,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or,or +,,,,,,,,,,,,,,,,,,,,,,,,,,or +,,,,,,,,,,,,,or,or,or,or,or,or,or,or,or,or,,,,or +,,,,,,,,,,,,,or,or,or,or,or,or,or,or,or,or,,,,or +,,,,,,,,,,,,,,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,,,,,,,,,,or,or,or +,,,,,,,,,,,,,,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,or +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,or,,,,,or,or +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,or,or,or,or,or,or,or +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,,,,,,or,or +,,,,,,,,,,,,,,,`,`,`,`,` + +#> + +,,,,,,,,,,,,,or,or,or,,or,or,or,,or,or,or,,or,or,or,,or,or,or + + + + + + + + + + + + + +,,,,,,,,,,,,,,,`,`,`,`,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,`,`,`,`,` + +#> + +,,,,,,,,,,,,,,or,or,,,or,or,,,or,or,,,or,or,,,or,or + + + + + + + + + + + + + +,,,,,,,,,,,,,,,`,`,`,`,` +,,,,,,,,,,,,,,,`,`,`,`,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,,,,,,,or +,,,,,,,,,,,,,,,`,`,`,`,` + +"#zone label(services_zones) start(18; 18) hidden() message(Don't forget to assign a doctor to the hospital! +If you'd like to fill your wells via bucket brigade instead of routing water (e.g. with the aquifer_tap library blueprint), activate the inactive pond zones one level down from where the wells will be built.) garbage dump, hospital, taverrn, barracks, archery range, and pond zones" +,,,,,,,,,,,,j/jail1,"j/jail1{name=""Jail 1""}(4x5)",j/jail1,j/jail1,j/jail1,"j{name=""Jail 2""}(4x5)",,,,"j{name=""Jail 3""}(4x5)",,,,"j{name=""Jail 4""}(4x5)",,,,"j{name=""Jail 5""}(4x5)" +,"b{location=tavern/bigpub name=""Rented room 1""}(1x3)","b{location=tavern/bigpub name=""Rented room 2""}(1x3)","b{location=tavern/bigpub name=""Rented room 3""}(1x3)",,"b{location=tavern/bigpub name=""Rented room 4""}(1x3)","b{location=tavern/bigpub name=""Rented room 5""}(1x3)","b{location=tavern/bigpub name=""Rented room 6""}(1x3)",,"b{location=tavern/bigpub name=""Rented room 7""}(1x3)","b{location=tavern/bigpub name=""Rented room 8""}(1x3)","b{location=tavern/bigpub name=""Rented room 9""}(1x3)",j/jail1,j/jail1,j/jail1,j/jail1,j/jail1,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,j/jail1,j/jail1,j/jail1,j/jail1,j/jail1,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,j/jail1,j/jail1,j/jail1,j/jail1,j/jail1,`,`,`,,`,`,`,,`,`,`,,`,`,` +"h{location=tavern/bigpub allow=residents name=""Grand hall tavern""}(13x31)",,`,,,,`,,,,`,,,j/jail1,j/jail1,j/jail1,j/jail1,,`,,,,`,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,`,o/interrogation,o/interrogation,o/interrogation,o/interrogation,o/interrogation,o/interrogation,o/interrogation +,`,`,`,`,`,`,`,`,`,`,`,,"B{name=""Marksdwarf barracks""}a{name=""Shooting gallery"" shoot_from=""south""}",Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,,`,o/interrogation,"j{name=""Drunk tank""}",j,j,j,j,o/interrogation +,`,`,`,`,`,`,`,`,`,`,`,,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,,`,o/interrogation,j,"o/interrogation{name=""Interrogation room"" assigned_unit=sheriff}(3x3)",`,`,j,o/interrogation +,`,`,`,`,`,`,`,`,`,`,`,,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,,`,o/interrogation,j,`,`,`,j,o/interrogation +,`,`,`,`,`,`,`,`,`,`,`,,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,`,`,o/interrogation,j,`,`,`,j,o/interrogation +,`,`,`,`,`,`,`,`,`,`,`,,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,,`,o/interrogation,j,j,j,j,j,o/interrogation +,`,`,`,`,`,`,`,`,`,`,`,,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,,,,,o/interrogation,o/interrogation,o/interrogation,o/interrogation,o/interrogation,o/interrogation,o/interrogation +,`,`,`,`,`,`,`,`,`,`,`,,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,Ba,,m{location=hospital name=Hospital allow=residents},,m,,m,,m,,m +,`,`,`,`,`,`,`,`,`,`,`,,,,,`,,`,,,,,m,,m,,m,,m,,m +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,m,,m,,m,,m,,m +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,m,m,m,m,m,m,m,m,m,m +,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,m,m,m,m,m,m,m,m,m,m +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,m,m,m,m,m,m,m,m,m,m +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,m,,m,,m,,m,,m +,`,`,`,`,`,`,`,`,`,`,`,,,,,,"d{name=""Garbage dump""}",,,,,,m,,m,,m,,m,,m +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,m,,m,,m,,m,,m +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` + +#> + +,,,,,,,,,,,,,`,"p{name=""Jail 1 cistern"" pond=true active=false}",`,,`,"p{name=""Jail 2 cistern"" pond=true active=false}",`,,`,"p{name=""Jail 3 cistern"" pond=true active=false}",`,,`,"p{name=""Jail 4 cistern"" pond=true active=false}",`,,`,"p{name=""Jail 5 cistern"" pond=true active=false}",` +,,,,,,,,,,,,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,,,,,,,,,,,,,`,,,,`,,,,`,,,,`,,,,` +,,,,,,,,,,,,,,`,,,,`,,,,`,,,,`,,,,` +,,,,,,,,,,,,,,`,,,,`,,,,`,,,,`,,,,` +,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,,,,` +,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,`,,,,,`,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,`,`,`,`,`,`,"p{name=""Hospital cistern"" pond=true active=false}" +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,,,,,,`,` +,,,,,,,,,,,,,,,`,`,`,`,` + +#place label(services_place) start(18; 18) hidden() + +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,"z{name=""Bolts quantum"" quantum=true}",`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,`,,`,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,"b/soap{name=""Soap"" take_from=""Metalworker quantum""}:=soap" +,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,b/soap +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,"c{name=""Garbage dump"" links_only=true}",,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,,`,` +,"c{name=""Prepared food"" barrels=-1}:+preparedmeals(5x5)",,,,`,,"c{name=""Booze"" barrels=-1}:+booze(5x5)",,,,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` + +#> + +,,,,,,,,,,,,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,,,,,,,,,,,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,,,,,,,,,,,,,`,,,,`,,,,`,,,,`,,,,` +,,,,,,,,,,,,,,`,,,,`,,,,`,,,,`,,,,` +,,,,,,,,,,,,,,`,,,,`,,,,`,,,,`,,,,` +,,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,"z{name=""Bolts feeder"" containers=0 take_from=""Metalworker quantum""}:-cat_ammo/type/,other/+bolts(10x1)",,,,,,,,,`,,,,` +,,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,`,`,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,,,,,,,,,,,,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,`,,,,,`,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,`,`,`,`,`,`,` +,,,,,,,,,,,,,,,`,`,`,`,`,,,,,,,,,,,,`,` +,,,,,,,,,,,,,,,`,`,`,`,` + +"#build label(services_build) start(18; 18) hidden() message(Remember to enqueue manager orders for this blueprint. +Assign a minecart to the training ammo quantum dump with ""assign-minecarts all"") build basic hospital, dining room, and barracks" + +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,A,A,A,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,"trackstopS{name=""Bolts dumper"" take_from=""Bolts feeder"" route=""Bolts quantum""}",`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,h,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,b,`,`,`,`,`,`,`,`,,`,,`,,`,,b,,R +,`,`,`,`,`,`,`,`,`,`,`,,,,,`,,`,,,,,`,,`,,`,,d,,d +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,h,`,`,`,`,t,`,`,`,l +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,`,,,,,,`,,`,,`,,`,,d +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,`,,`,,`,,`,,R +,`,`,`,`,`,`,t,c,c,t,` +,`,`,`,`,`,`,t,c,c,t,` +,`,`,`,`,`,`,t,c,c,t,` +,`,`,`,`,`,`,t,c,c,t,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,h,`,`,`,`,` +,,,,`,`,,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` + +#dig label(services_smooth) start(18; 18) hidden() smooth the floor where the pedestal will go + +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,`,,`,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,s1,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,`,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` + +#place label(services_place2) start(18; 18) hidden() jail food and booze + +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,"c{name=""Jail booze"" barrels=-1 take_from=""Booze""}:+booze(1x2)",,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,"c{name=""Jail food"" barrels=-1 take_from=""Prepared food""}:+preparedmeals(2x1)",,`,,`,`,`,,`,`,` +,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,~,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,`,,`,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,~,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,,`,` +,~,~,~,~,~,,~,~,~,~,~ +,~,~,~,~,~,,~,~,~,~,~ +,~,~,~,~,~,,~,~,~,~,~ +,~,~,~,~,~,,~,~,~,~,~ +,~,~,~,~,~,,~,~,~,~,~ + +#build label(services_build2) start(18; 18) hidden() message(Remember to enqueue manager orders for this blueprint.) expand each room + +,`,b,`,,`,b,`,,`,b,`,,`,`,`,,`,`,`,,t,l,b,,`,`,`,,`,`,` +,`,h,`,,`,h,`,,`,h,`,,`,`,`,,`,`,`,,c,v,`,,`,`,`,,`,`,` +,`,f,`,,`,f,`,,`,f,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,`,,,,`,,,,`,,,,`,,,,`,,,,d,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,A,A,A,~,~,~,A,A,A,A,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,c,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,t,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,~,`,`,`,`,`,`,`,`,`,`,`,c,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,h,b,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,~,`,`,`,`,`,`,`,h +,`,`,`,`,`,`,`,`,`,`,`,,~,`,`,`,`,`,`,`,b,,b,,b,,b,,~,,~ +,`,`,`,`,`,`,`,`,`,`,`,,,,,`,,`,,,,,d,,d,,d,,~,,~ +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,` +,`,`,`,`,`,F,`,`,`,`,`,,`,,`,`,`,`,`,,`,,~,`,`,`,`,~,`,`,`,~ +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,`,,,,,,`,,`,,`,,`,,~ +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,`,,`,,`,,`,,~ +,`,t,c,c,t,`,~,~,~,~,` +,`,t,c,c,t,`,~,~,~,~,` +,`,t,c,c,t,`,~,~,~,~,` +,`,t,c,c,t,`,~,~,~,~,` +,`,`,`,`,`,`,`,`,`,`,` +,h,`,`,`,`,~,`,`,`,`,h +,,,,`,`,,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` + +#dig label(services_smooth2) start(18; 18) hidden() smooth the floor where the statues will go + +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,` +,`,`,`,s1,`,`,`,s1,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,` +,s1,`,`,`,`,`,`,`,`,`,s1,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,s1,`,`,`,`,`,`,`,`,`,s1,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,s1,`,`,`,`,`,`,`,`,`,s1,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,` +,s1,`,`,`,`,`,`,`,`,`,s1,,`,`,`,`,`,`,`,`,`,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,`,,`,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,`,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,s1,`,`,`,`,`,s1,`,` +,,,,`,`,,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` + +#place label(services_place3) start(18; 18) hidden() remaining jail food and booze + +,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,`,`,`,,`,`,`,,`,`,`,,`,`,"c{name=""Jail booze"" barrels=-1 take_from=""Booze""}:+booze(1x2)",,`,`,"c{name=""Jail booze"" barrels=-1 take_from=""Booze""}:+booze(1x2)",,`,`,~,,`,`,"c{name=""Jail booze"" barrels=-1 take_from=""Booze""}:+booze(1x2)",,`,`,"c{name=""Jail booze"" barrels=-1 take_from=""Booze""}:+booze(1x2)" +,`,`,`,,`,`,`,,`,`,`,,"c{name=""Jail food"" barrels=-1 take_from=""Prepared food""}:+preparedmeals(2x1)",,`,,"c{name=""Jail food"" barrels=-1 take_from=""Prepared food""}:+preparedmeals(2x1)",,`,,~,`,`,,"c{name=""Jail food"" barrels=-1 take_from=""Prepared food""}:+preparedmeals(2x1)",,`,,"c{name=""Jail food"" barrels=-1 take_from=""Prepared food""}:+preparedmeals(2x1)",,` +,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,~,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,`,,`,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,~,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,` +,,,,`,`,,`,` +,~,~,~,~,~,,~,~,~,~,~ +,~,~,~,~,~,,~,~,~,~,~ +,~,~,~,~,~,,~,~,~,~,~ +,~,~,~,~,~,,~,~,~,~,~ +,~,~,~,~,~,,~,~,~,~,~ + +#build label(services_build3) start(18; 18) hidden() message(Remember to enqueue manager orders for this blueprint.) finalize furniture + +,b,~,b,,b,~,b,,b,~,b,,t,l,b,,t,l,b,,~,~,~,,t,l,b,,t,l,b +,h,~,h,,h,~,h,,h,~,h,,c,v,`,,c,v,`,,~,~,`,,c,v,`,,c,v,` +,f,~,f,,f,~,f,,f,~,f,,`,`,`,,`,`,`,,`,`,`,,`,`,`,,`,`,` +,,d,,,,d,,,,d,,,,d,,,,d,,,,~,,,,d,,,,d +,`,`,`,s,`,`,`,s,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,,,,,` +,s,`,`,`,`,`,`,`,`,`,s,,~,~,~,~,~,~,~,~,~,~,`,,`,,v,v,v,v,v +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,`,,`,,v,`,~,`,v +,s,`,`,`,`,`,`,`,`,`,s,,`,`,`,`,`,`,`,`,`,`,`,,`,,v,`,~,`,v +,`,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,~,`,`,`,`,`,`,d,`,d,v,`,~,`,v +,s,`,`,`,`,`,`,`,`,`,s,,`,`,`,`,`,`,`,`,`,~,~,,`,,v,v,v,v,v +,`,`,`,`,`,`,`,`,`,`,`,,~,h,h,h,h,h,h,h,~ +,s,`,`,`,`,`,`,`,`,`,s,,~,b,b,b,b,b,b,b,~,,~,,~,,~,,~,,~ +,`,`,`,`,`,`,`,`,`,`,`,,,,,d{name=Services},,d{name=Services},,,,,~,,~,,~,,~,,~ +,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,`,`,`,`,`,`,`,`,`,`,d,`,d{name=Services},`,`,`,`,`,d{name=Services},`,d,`,`,`,`,`,`,`,`,`,` +,`,t,c,`,`,~,`,`,c,t,`,,s,,`,`,`,`,`,,s,,~,`,`,t,`,~,`,`,`,~ +,`,t,c,`,`,`,`,`,c,t,`,d,`,d{name=Services},`,`,`,`,`,d{name=Services},`,d,`,`,`,`,`,`,`,`,`,` +,`,t,c,c,t,`,t,c,c,t,`,,,,`,`,`,`,`,,,,`,,`,,`,,`,,` +,`,t,c,c,t,`,t,c,c,t,`,,,,,,`,,,,,,d,,d,,d,,d,,` +,`,t,c,c,t,`,t,c,c,t,`,,,,,,,,,,,,b,,b,,b,,b,,` +,`,~,~,~,~,`,~,~,~,~,` +,`,~,~,~,~,`,~,~,~,~,` +,`,~,~,~,~,`,~,~,~,~,` +,`,~,~,~,~,`,~,~,~,~,` +,`,`,`,`,`,`,`,`,`,`,` +,~,`,s,`,`,~,`,`,s,`,~ +,,,,d,d,,d,d +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` +,`,`,`,`,`,,`,`,`,`,` + +#notes label(guildhall_help) guildhall level walkthrough +"Eight 7x7 rooms for guildhalls, temples, libraries, etc." +Screenshot: https://drive.google.com/file/d/1mt66QOkfBqFLtw6AJKU6GNYmhB72XSJG +"" +Features: +"- Big rooms, optionally pre-furnished. Double-thick walls to ensure engravings add maximum value. Pre-made meeting zones can be made into locations (e.g. guildhalls) as needed. Optional pre-configured library/temple combo." +"" +"Each 7x7 room will be worth about 3000 when fully engraved (with random quality of engravings). This will get you past the first ""tier"" threshold at standard difficulty settings. Add artifacts to the display cases or other fancy decorations if you need more value. You can also assign multiple 7x7 rooms to the same zone or location and gain more value that way." +"" +Guildhall Walkthrough: +1) Dig out the rooms with /guildhall1. +"" +"2) Once the area is dug out, choose a /guildhall2 variant based on your needs. For your first copy of this level, you probably want /guildhall2_default, which configures the temple and library zones as fully usable locations. For later copies you probably want to create all locations yourself, so you should choose /guildhall2_no_locations if you want the default furnishings or /guildhall2_custom for just the zones and doors, leaving the furnishings up to you. Generate manager orders for your chosen variant." +"" +"Note that the default temple and library are created ""Citizens and Long-Term Residents only"", but you can change this in the location configuration screen if you want them to attract visitors. If you need more rooms, you can dig another /guildhall1 in an unused z-level." +"#dig label(guildhall1) start(15; 15; central stairs) message(Once the area is dug out, continue with /guildhall2.)" + + +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,,,,,,,,d,,,,d,,d,,,,d +,,,,,,,,,,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,d,,,d,,d,,,d,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,d,,d,d,d,d,d,,d,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,d,,d,`,`,`,d,,d,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,d,,d,d,d,d,d,,d,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,d,,,d,,d,,,d,,d,d,d,d,d,d,d +,,,,,,,,,,d,d,d,d,d,d,d,d,d +,,,,,,,,,d,,,,d,,d,,,,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d + + +#meta label(guildhall2_default) furnished with default temple and library +locations/guildhall_locations +doors/guildhall_doors +furnish/guildhall_furnish +smooth/guildhall_smooth +"" +#meta label(guildhall2_no_locations) fully furnished and zoned but no locations +zones/guildhall_zones +doors/guildhall_doors +furnish/guildhall_furnish +smooth/guildhall_smooth +"" +#meta label(guildhall2_custom) only zones and doors +zones/guildhall_zones +doors/guildhall_doors +"" +"#zone label(guildhall_locations) start(15; 15; central stairs) hidden() message(The library and temple are restricted to residents only by default. If you'd like them to attract vistors, please go to the location screen and change the restrictions.) declare a library and temple" + +,m(9x9),,,,,,,,,"m{location=temple name=""All-inclusive temple"" allow=residents}(9x9)",,,,,,,,,m(9x9) +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,,,,,,,,~,,,,~,,~,,,,~ +,m(9x9),,,,,,,,,`,`,`,`,`,`,`,`,`,m(9x9) +,,`,`,`,`,`,`,`,,`,,,~,,~,,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,~,`,~,`,,,,`,~,`,~,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,,`,,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,~,`,~,`,,,,`,~,`,~,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,,~,,~,,,`,,`,`,`,`,`,`,` +,,,,,,,,,,`,`,`,`,`,`,`,`,` +,m(9x9),,,,,,,,~,m{location=library name=Library allow=residents}(9x9),,,~,,~,,,,m(9x9) +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` + + +"#zone label(guildhall_zones) start(15; 15; central stairs) hidden() designate zones, ready for custom locations to be assigned" + +,m(9x9),,,,,,,,,m(9x9),,,,,,,,,m(9x9) +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,,,,,,,,~,,,,~,,~,,,,~ +,m(9x9),,,,,,,,,`,`,`,`,`,`,`,`,`,m(9x9) +,,`,`,`,`,`,`,`,,`,,,~,,~,,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,~,`,~,`,,,,`,~,`,~,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,,`,,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,~,`,~,`,,,,`,~,`,~,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,,~,,~,,,`,,`,`,`,`,`,`,` +,,,,,,,,,,`,`,`,`,`,`,`,`,` +,m(9x9),,,,,,,,~,m(9x9),,,~,,~,,,,m(9x9) +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` + + +#build label(guildhall_doors) start(15; 15; central stairs) hidden() message(Remember to enqueue manager orders for this blueprint.) build doors + + +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,,,,,,,,d,,,,d,,d,,,,d +,,,,,,,,,,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,,d{name=Guidhall},,d{name=Guidhall},,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,d,`,d{name=Guidhall},`,,,,`,d{name=Guidhall},`,d,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,,`,,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,d,`,d{name=Guidhall},`,,,,`,d{name=Guidhall},`,d,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,,d{name=Guidhall},,d{name=Guidhall},,,`,,`,`,`,`,`,`,` +,,,,,,,,,,`,`,`,`,`,`,`,`,` +,,,,,,,,,d,,,,d,,d,,,,d +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` + + +"#build label(guildhall_furnish) start(15; 15; central stairs) hidden() furnish 4 guildhalls, 3 temples, and a library" + + +,,F,`,`,`,s,`,`,,,F,`,`,c,`,`,f,,,`,`,s,`,`,`,F +,,`,`,c,`,`,`,`,,,`,`,`,~a,h,`,s,,,`,`,`,`,c,`,` +,,`,c,t,c,`,`,s,,,`,`,`,`,`,`,`,,,s,`,`,c,t,c,` +,,`,`,c,`,c,`,`,,,`,`,`,`,`,`,`,,,`,`,c,`,c,`,` +,,s,`,`,c,t,c,`,,,`,`,c,c,c,`,`,,,`,c,t,c,`,`,s +,,`,`,`,`,c,`,`,,,`,`,c,c,c,`,`,,,`,`,c,`,`,`,` +,,`,`,s,`,`,`,`,,,t,`,`,`,`,`,t,,,`,`,`,`,s,`,` +,,,,,,,,,~,,,,~,,~,,,,~ +,,,,,,,,,,`,`,`,`,`,`,`,`,` +,,f,s,`,`,`,`,t,,`,,,~,,~,,,`,,t,`,`,`,`,s,f +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,`,h,`,`,c,c,`,~,`,~,`,,,,`,~,`,~,`,c,c,`,`,h,` +,,c,~a,`,`,c,c,`,,`,,`,,`,,`,,`,,`,c,c,`,`,~a,c +,,`,`,`,`,c,c,`,~,`,~,`,,,,`,~,`,~,`,c,c,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,F,`,`,`,`,`,t,,`,,,~,,~,,,`,,t,`,`,`,`,`,F +,,,,,,,,,,`,`,`,`,`,`,`,`,` +,,,,,,,,,~,,,,~,,~,,,,~ +,,`,`,s,`,`,`,`,,,t,`,`,`,`,`,t,,,`,`,`,`,s,`,` +,,`,`,`,`,c,`,`,,,`,`,`,`,`,`,`,,,`,`,c,`,`,`,` +,,s,`,`,c,t,c,`,,,t,c,`,`,`,c,t,,,`,c,t,c,`,`,s +,,`,`,c,`,c,`,`,,,t,c,`,`,`,c,t,,,`,`,c,`,c,`,` +,,`,c,t,c,`,`,s,,,t,c,`,`,`,c,t,,,s,`,`,c,t,c,` +,,`,`,c,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,c,`,` +,,F,`,`,`,s,`,`,,,h,~c,~c,s,~c,~c,h,,,`,`,s,`,`,`,F + + +#dig label(guildhall_smooth) start(15; 15; central stairs) hidden() smooth statue tiles + + +,,s,`,`,`,s,`,`,,,s,`,`,`,`,`,`,,,`,`,s,`,`,`,s +,,`,`,`,`,`,`,`,,,`,`,`,s,`,`,s,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,s,,,`,`,`,`,`,`,`,,,s,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,s,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,s +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,s,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,s,`,` +,,,,,,,,,`,,,,`,,`,,,,` +,,,,,,,,,,`,`,`,`,`,`,`,`,` +,,`,s,`,`,`,`,`,,`,,,`,,`,,,`,,`,`,`,`,`,s,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,`,`,`,`,`,` +,,`,s,`,`,`,`,`,,`,,`,,`,,`,,`,,`,`,`,`,`,s,` +,,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,`,,`,`,`,`,`,,`,,`,`,`,`,`,`,` +,,s,`,`,`,`,`,`,,`,,,`,,`,,,`,,`,`,`,`,`,`,s +,,,,,,,,,,`,`,`,`,`,`,`,`,` +,,,,,,,,,`,,,,`,,`,,,,` +,,`,`,s,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,s,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,s,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,s +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,`,`,`,`,`,`,s,,,`,`,`,`,`,`,`,,,s,`,`,`,`,`,` +,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,,s,`,`,`,s,`,`,,,`,s,s,s,s,s,`,,,`,`,s,`,`,`,s + + +#notes label(beds_help) walkthrough for the suites and apartments levels +Suites for nobles and apartments for the teeming masses +Suites screenshot: https://drive.google.com/file/d/16XRb1w5zFoyVq2LBMx_aCwOyjFq7GULc +Apt. screenshot: https://drive.google.com/file/d/16-NXlodLIQjeZUMSmsWRafeytwU2dXQo +"" +Features: +- Well-appointed suites to satisfy nobles or citizens with a need for opulence +"- Suite rooms are multi-functional. Any suite can be zoned as a bedroom, office, dining hall, or tomb. If a noble requires more wealth than what a default room provides, you can smooth, engrave, add furniture, or include multiple rooms in the zone. A default suites level can fully satisfy a monarch if each zone covers four (engraved) rooms." +- Apartments with beds and storage to keep dwarves happy and the fortress clean +"" +Suites Walkthrough: +1) Dig out the suites layer with /suites1. +"" +"2) Once the area is dug out, choose a /suites2 variant based on your needs. For your first copy of this level, you probably want /suites2_default, which defines zones and assigns them to the usual cohort of demanding nobles and administrators. For later copies where your needs are ad hoc, you can choose /suites2_no_zones. Generate manager orders for your chosen variant." +"" +Apartments Walkthrough: +"1) Dig out one layer of apartments with /apartments1, or 3 layers at once (180 bedrooms total) by configuring gui/quickfort to repeat down 3 levels." +"" +"2) Once a layer is dug out, build furniture with /apartments2. Generate manager orders for /apartments2." +"#dig label(suites1) start(18; 18; central stairs) message(Once the area is dug out, run /suites2) noble suites" + +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,,,,d,,,,,,,d,,,,d,d,d,,,,d,,,,,,,d,,,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,,,,,,,,,,,,,,d,d,d,,,,,,,,,,,,,,,d +,d,,,,,,,,,,,,,,,d,d,d,,,,,,,,,,,,,,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,,,d,,,,,,,d,,,,d,d,d,,,,d,,,,,,,d,,,,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,,d,d,d,d,d,d,d,d,d,d,,d,`,~,`,d,,d,d,d,d,d,d,d,d,d,d,,d,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,,,,d,,,,,,,d,,,,d,d,d,,,,d,,,,,,,d,,,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,,,,,,,,,,,,,,d,d,d,,,,,,,,,,,,,,,d +,d,,,,,,,,,,,,,,,d,d,d,,,,,,,,,,,,,,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,,,d,d,d,d,d,d,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,d,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,d,d,d,d,d,,,d,d,d,d,d,,d,,d,,d,d,d,d,d,,,d,d,d,d,d,,d +,d,,,,d,,,,,,,d,,,,d,d,d,,,,d,,,,,,,d,,,,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d + +"#meta label(suites2_default) start(central stairs) message(Remember to enqueue manager orders for this blueprint.) build furniture, set traffic patterns, create zones, and assign them to nobles and administrators" +traffic_suites/suites_traffic +build_suites/suites_build +smooth_suites/suites_smooth +zone_suites/suites_zone +"" +"#meta label(suites2_no_zones) start(central stairs) message(Remember to enqueue manager orders for this blueprint. +rooms are left unzoned so you can configure them for specific nobles.) build furniture and set traffic patterns" +traffic_suites/suites_traffic +build_suites/suites_build +smooth_suites/suites_smooth +#dig label(suites_traffic) start(18; 18; central stairs) hidden() don't path through other dwarves' rooms + +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,,,,or,,,,,,,or,,,,`,`,`,,,,or,,,,,,,or,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,or,`,`,`,`,`,,,`,`,`,`,`,or,oh,`,oh,or,`,`,`,`,`,,,`,`,`,`,`,or,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,,,,,,,,,,,,oh,`,oh,,,,,,,,,,,,,,,` +,`,,,,,,,,,,,,,,,oh,`,oh,,,,,,,,,,,,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,or,`,`,`,`,`,,,`,`,`,`,`,or,oh,`,oh,or,`,`,`,`,`,,,`,`,`,`,`,or,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,or,,,,,,,or,,,,oh,`,oh,,,,or,,,,,,,or,,,,` +,`,`,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,`,`,`,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,`,` +,`,`,,`,`,`,`,`,`,`,`,`,`,,`,`,~,`,`,,`,`,`,`,`,`,`,`,`,`,,`,` +,`,`,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,`,`,`,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,oh,`,` +,`,,,,or,,,,,,,or,,,,oh,`,oh,,,,or,,,,,,,or,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,or,`,`,`,`,`,,,`,`,`,`,`,or,oh,`,oh,or,`,`,`,`,`,,,`,`,`,`,`,or,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,,,,,,,,,,,,oh,`,oh,,,,,,,,,,,,,,,` +,`,,,,,,,,,,,,,,,oh,`,oh,,,,,,,,,,,,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,or,`,`,`,`,`,,,`,`,`,`,`,or,oh,`,oh,or,`,`,`,`,`,,,`,`,`,`,`,or,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,`,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,oh,,oh,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,or,,,,,,,or,,,,`,`,`,,,,or,,,,,,,or,,,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` + +#build label(suites_build) start(18; 18; central stairs) hidden() + +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,,,,d,,,,,,,d,,,,`,`,`,,,,d,,,,,,,d,,,,` +,`,,a,r,`,`,h,,,h,`,`,r,a,,d,,d,,a,r,`,`,h,,,h,`,`,r,a,,` +,`,,`,`,`,`,h,,,h,`,`,`,`,,`,`,`,,`,`,`,`,h,,,h,`,`,`,`,,` +,`,d,`,`,b,`,`,,,`,`,b,`,`,d,`,`,`,d,`,`,b,`,`,,,`,`,b,`,`,d,` +,`,,c,`,`,`,f,,,f,`,`,`,c,,`,`,`,,c,`,`,`,f,,,f,`,`,`,c,,` +,`,,t,`,s,`,n,,,n,`,s,`,t,,`,s,`,,t,`,s,`,n,,,n,`,s,`,t,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,,t,`,s,`,n,,,n,`,s,`,t,,`,s,`,,t,`,s,`,n,,,n,`,s,`,t,,` +,`,,c,`,`,`,f,,,f,`,`,`,c,,`,`,`,,c,`,`,`,f,,,f,`,`,`,c,,` +,`,d,`,`,b,`,`,,,`,`,b,`,`,d,`,`,`,d,`,`,b,`,`,,,`,`,b,`,`,d,` +,`,,`,`,`,`,h,,,h,`,`,`,`,,`,`,`,,`,`,`,`,h,,,h,`,`,`,`,,` +,`,,a,r,`,`,h,,,h,`,`,r,a,,d{name=Suites},,d{name=Suites},,a,r,`,`,h,,,h,`,`,r,a,,` +,`,,,,d,,,,,,,d,,,,`,`,`,,,,d,,,,,,,d,,,,` +,`,`,d,`,`,`,`,`,`,`,`,`,`,d{name=Suites},`,`,`,`,`,d{name=Suites},`,`,`,`,`,`,`,`,`,`,d,`,` +,`,`,,`,`,`,s,`,`,s,`,`,`,,`,`,~,`,`,,`,`,`,s,`,`,s,`,`,`,,`,` +,`,`,d,`,`,`,`,`,`,`,`,`,`,d{name=Suites},`,`,`,`,`,d{name=Suites},`,`,`,`,`,`,`,`,`,`,d,`,` +,`,,,,d,,,,,,,d,,,,`,`,`,,,,d,,,,,,,d,,,,` +,`,,a,r,`,`,h,,,h,`,`,r,a,,d{name=Suites},,d{name=Suites},,a,r,`,`,h,,,h,`,`,r,a,,` +,`,,`,`,`,`,h,,,h,`,`,`,`,,`,`,`,,`,`,`,`,h,,,h,`,`,`,`,,` +,`,d,`,`,b,`,`,,,`,`,b,`,`,d,`,`,`,d,`,`,b,`,`,,,`,`,b,`,`,d,` +,`,,c,`,`,`,f,,,f,`,`,`,c,,`,`,`,,c,`,`,`,f,,,f,`,`,`,c,,` +,`,,t,`,s,`,n,,,n,`,s,`,t,,`,s,`,,t,`,s,`,n,,,n,`,s,`,t,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,,t,`,s,`,n,,,n,`,s,`,t,,`,s,`,,t,`,s,`,n,,,n,`,s,`,t,,` +,`,,c,`,`,`,f,,,f,`,`,`,c,,`,`,`,,c,`,`,`,f,,,f,`,`,`,c,,` +,`,d,`,`,b,`,`,,,`,`,b,`,`,d,`,`,`,d,`,`,b,`,`,,,`,`,b,`,`,d,` +,`,,`,`,`,`,h,,,h,`,`,`,`,,`,`,`,,`,`,`,`,h,,,h,`,`,`,`,,` +,`,,a,r,`,`,h,,,h,`,`,r,a,,d,,d,,a,r,`,`,h,,,h,`,`,r,a,,` +,`,,,,d,,,,,,,d,,,,`,`,`,,,,d,,,,,,,d,,,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` + +#dig label(suites_smooth) start(18; 18; central stairs) hidden() smooth statue tiles + +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,,,,`,,,,,,,`,,,,`,`,`,,,,`,,,,,,,`,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,s,`,`,,,`,`,s,`,`,,`,s,`,,`,`,s,`,`,,,`,`,s,`,`,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,,`,`,s,`,`,,,`,`,s,`,`,,`,s,`,,`,`,s,`,`,,,`,`,s,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,`,,,,,,,`,,,,`,`,`,,,,`,,,,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,,`,`,`,s,`,`,s,`,`,`,,`,`,~,`,`,,`,`,`,s,`,`,s,`,`,`,,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,,,,`,,,,,,,`,,,,`,`,`,,,,`,,,,,,,`,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,s,`,`,,,`,`,s,`,`,,`,s,`,,`,`,s,`,`,,,`,`,s,`,`,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,,`,`,s,`,`,,,`,`,s,`,`,,`,s,`,,`,`,s,`,`,,,`,`,s,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,`,,,,,,,`,,,,`,`,`,,,,`,,,,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` + +#zone label(suites_zone) start(18; 18; central stairs) hidden() + +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,h{assigned_unit=sheriff},h,h,b{assigned_unit=sheriff},b,b,b,o{assigned_unit=mayor}(7x7),,,`,,,,`,`,`,o{assigned_unit=baron}(7x7),,,`,,,,T{assigned_unit=baron}(7x7),,,`,,,,` +,`,h,h,h,b,b,b,b,,`,`,`,`,`,,`,,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,h,h,h,b,b,b,b,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,h,h,h,b,b,b,b,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,`,h,h,h,h,b,b,b,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,h,h,h,h,b,b,b,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,h,h,h,h,b,b,b,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,h{assigned_unit=mayor}(7x7),,,,,,,b{assigned_unit=mayor}(7x7),,,,,,,`,`,`,b{assigned_unit=baron}(7x7),,,,,,,h{assigned_unit=baron}(7x7),,,,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,`,,,,,,,`,,,,`,`,`,,,,`,,,,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,,`,`,`,`,`,`,`,`,`,`,,`,`,`,`,`,,`,`,`,`,`,`,`,`,`,`,,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,h{assigned_unit=outpost_liaison}(7x7),,,`,,,,b{assigned_unit=outpost_liaison}(7x7),,,`,,,,`,`,`,b{assigned_unit=monarch}(7x7),,,`,,,,h{assigned_unit=monarch}(7x7),,,`,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,,,,,,,,,,,,`,`,`,,,,,,,,,,,,,,,` +,`,T{assigned_unit=monarch}(7x7),,,,,,,o{assigned_unit=outpost_liaison}(7x7),,,,,,,`,`,`,o{assigned_unit=monarch}(14x7),,,,,,,,,,,,,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,`,`,`,`,`,`,,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,,,`,`,`,`,`,`,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,`,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,`,`,`,`,`,,,`,`,`,`,`,,`,,`,,`,`,`,`,`,,,`,`,`,`,`,,` +,`,,,,`,,,,,,,`,,,,`,`,`,,,,`,,,,,,,`,,,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` + +"#dig label(apartments1) start(18; 18; central stairs) message(Once the area is dug out, continue with /apartments2.) apartment complex" + +,,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,,,,d,,,d,,,d,,,d,,,d,,d,,,d,,,d,,,d,,,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,,d,,,d,,,d,,,d,,d,d,d,,d,,,d,,,d,,,d,,,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,,,,,,,,,,,,,,,,d,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,,,d,,,d,,,d,,,d,,,d,d,d,,,d,,,d,,,d,,,d,,,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,,d,`,~,`,d,,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,`,`,`,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,,,d,,,d,,,d,,,d,,,d,d,d,,,d,,,d,,,d,,,d,,,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,,,,,,,,,,,,,,,,d,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,,d,,,d,,,d,,,d,,,d,,d,d,d,,d,,,d,,,d,,,d,,,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,,,,d,,,d,,,d,,,d,,,d,,d,,,d,,,d,,,d,,,d +,,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d +,,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d,,d,d + +#meta label(apartments2) start(central stairs) zone rooms and build furniture +zone_apartments/apartments_rooms +build_apartments/apartments_build +#zone label(apartments_rooms) start(18; 18; central stairs) hidden() zone rooms +,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5) +,,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,,,,`,,,`,,,`,,,`,,,`,,`,,,`,,,`,,,`,,,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +b(4x5),,`,b(4x5),,`,b(4x5),,`,b(4x5),,`,b(4x5),,`,,`,`,`,b(4x5),`,,b(4x5),`,,b(4x5),`,,b(4x5),`,,b(4x5),` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,,`,`,`,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5) +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,,,`,,,`,,,`,,,`,,,`,`,`,,,`,,,`,,,`,,,`,,,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,~,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +b(4x5),`,,b(4x5),`,,b(4x5),`,,b(4x5),`,,b(4x5),`,,,`,`,`,b(4x5),,`,b(4x5),,`,b(4x5),,`,b(4x5),,`,b(4x5),,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,,`,`,`,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5),,,b(4x5) +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,,`,,,`,,,`,,,`,,,`,,`,`,`,,`,,,`,,,`,,,`,,,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,b(4x5),,`,b(4x5),,`,b(4x5),,`,b(4x5),,`,b(4x5),,`,b(4x5),`,,b(4x5),`,,b(4x5),`,,b(4x5),`,,b(4x5),` +,,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,` + +#build label(apartments_build) start(18; 18; central stairs) hidden() message(Remember to enqueue manager orders for this blueprint.) build furniture + +,,,f,h,,f,h,,f,h,,f,h,,f,h,,h,f,,h,f,,h,f,,h,f,,h,f +,,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,,,b,`,,b,`,,b,`,,b,`,,b,`,,`,b,,`,b,,`,b,,`,b,,`,b +,,,,d,,,d,,,d,,,d,,,d,,d,,,d,,,d,,,d,,,d +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,d,,,d,,,d,,,d,,,d,,`,`,`,,d,,,d,,,d,,,d,,,d +,b,`,,b,`,,b,`,,b,`,,b,`,,`,`,`,,`,b,,`,b,,`,b,,`,b,,`,b +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,f,h,,f,h,,f,h,,f,h,,f,h,,`,`,`,,h,f,,h,f,,h,f,,h,f,,h,f +,,,,,,,,,,,,,,,,`,`,` +,h,f,,h,f,,h,f,,h,f,,h,f,,`,`,`,,f,h,,f,h,,f,h,,f,h,,f,h +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,`,b,,`,b,,`,b,,`,b,,`,b,,d{name=Apartments},,d{name=Apartments},,b,`,,b,`,,b,`,,b,`,,b,` +,d,,,d,,,d,,,d,,,d,,,`,`,`,,,d,,,d,,,d,,,d,,,d +,`,`,`,`,`,`,`,`,`,`,`,`,`,d{name=Apartments},`,`,`,`,`,d{name=Apartments},`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,,`,`,~,`,`,,`,`,`,`,`,`,`,`,`,`,`,`,` +,`,`,`,`,`,`,`,`,`,`,`,`,`,d{name=Apartments},`,`,`,`,`,d{name=Apartments},`,`,`,`,`,`,`,`,`,`,`,`,` +,d,,,d,,,d,,,d,,,d,,,`,`,`,,,d,,,d,,,d,,,d,,,d +,`,b,,`,b,,`,b,,`,b,,`,b,,d{name=Apartments},,d{name=Apartments},,b,`,,b,`,,b,`,,b,`,,b,` +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,h,f,,h,f,,h,f,,h,f,,h,f,,`,`,`,,f,h,,f,h,,f,h,,f,h,,f,h +,,,,,,,,,,,,,,,,`,`,` +,f,h,,f,h,,f,h,,f,h,,f,h,,`,`,`,,h,f,,h,f,,h,f,,h,f,,h,f +,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,b,`,,b,`,,b,`,,b,`,,b,`,,`,`,`,,`,b,,`,b,,`,b,,`,b,,`,b +,,d,,,d,,,d,,,d,,,d,,`,`,`,,d,,,d,,,d,,,d,,,d +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,` +,,,,d,,,d,,,d,,,d,,,d,,d,,,d,,,d,,,d,,,d +,,,b,`,,b,`,,b,`,,b,`,,b,`,,`,b,,`,b,,`,b,,`,b,,`,b +,,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,`,,`,` +,,,f,h,,f,h,,f,h,,f,h,,f,h,,h,f,,h,f,,h,f,,h,f,,h,f + +#notes label(crypt_help) crypt level walkthrough +Places to rest your dead +Screenshot: https://drive.google.com/file/d/16iT_ho7BIRPD_eofuxdlVQ4FunR1Li23 +"" +Features: +"- Staged crypt expansion that grows with your, um, need" +- 20 tombs in stage 1 +- 192 additional tombs in stage 2 (212 tombs total) +"- Extendable in any direction by reapplying the blueprints to the North, South, East, or West, overlapping by one tile" +"" +Crypt Walkthrough: +1) Dig out the layer with /crypt1. +"" +"2) Once the area is dug out, add initial tombs with /crypt2." +"" +"3) If/when you need additional tombs, apply /crypt3." +"#dig label(crypt1) start(18; 18; central stairs) message(Once the area is dug out, continue with /crypt2.) crypt complex" + +,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,d,d,,d,,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,,,,d,d,d,,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,d,d,d,,,,d,d,d,d,,d,,d,,d,,d,,d +,,,,,,,,,,,,d,d,d,d,,~,,d,d,d,d +,,d,,d,,d,,d,,d,,d,d,d,d,,,,d,d,d,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,,,,d,d,d,,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,d,d,,d,,d,,d,,d,,d,,d,,d +,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,d,d,d,d,d,d,d,d,d,d,d,d,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d,d +,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d,,d +,,,,,,,,,,,,d,d,d,d,d,d,d,d,d,d,d + +#meta label(crypt2) start(central stairs) small crypt that can be extended later +zone/crypt_zone +build/crypt_build +"" +#meta label(crypt3) start(central stairs) crypt extension +zone_extended/crypt_extended_zone +build_extended/crypt_extended_build +#zone label(crypt_zone) start(18; 18; central stairs) hidden() zone tombs + + + + + + + + + +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,` +,,,,,,,,,,,`,`,,,,,,,,,,`,` +,,,,,,,,,,,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,` +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,`,,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),,` +,,,,,,,,,,,`,`,,,,`,`,`,,,,`,` +,,,,,,,,,,,,`,`,`,`,,,,`,`,`,` +,,,,,,,,,,,,`,`,`,`,,~,,`,`,`,` +,,,,,,,,,,,,`,`,`,`,,,,`,`,`,` +,,,,,,,,,,,`,`,,,,`,`,`,,,,`,` +,,,,,,,,,,,,`,,T{pets=true}(1x1),,`,`,`,,T{pets=true}(1x1),,` +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,` +,,,,,,,,,,,`,`,,,,,,,,,,`,` +,,,,,,,,,,,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,` +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` + + + + + + + + + +#build label(crypt_build) start(18; 18; central stairs) hidden() message(Remember to enqueue manager orders for this blueprint.) build urns + + + + + + + + + +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,`,,n,,n,,n,,n,,` +,,,,,,,,,,,`,`,,,,,,,,,,`,` +,,,,,,,,,,,,`,,n,,n,,n,,n,,` +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,`,,n,,`,s{name=Crypt},`,,n,,` +,,,,,,,,,,,`,`,,,,`,`,`,,,,`,` +,,,,,,,,,,,,`,`,`,`,,,,`,`,`,` +,,,,,,,,,,,,`,`,s{name=Crypt},`,,~,,`,s{name=Crypt},`,` +,,,,,,,,,,,,`,`,`,`,,,,`,`,`,` +,,,,,,,,,,,`,`,,,,`,`,`,,,,`,` +,,,,,,,,,,,,`,,n,,`,s{name=Crypt},`,,n,,` +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,,,,,,,,,,,`,,n,,n,,n,,n,,` +,,,,,,,,,,,`,`,,,,,,,,,,`,` +,,,,,,,,,,,,`,,n,,n,,n,,n,,` +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` + + + + + + + + + +#zone label(crypt_extended_zone) start(18; 18; central stairs) hidden() zone more tombs + +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,~,,~,,~,,~,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,~,,~,,~,,~,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,~,,`,`,`,,~,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,`,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,`,`,`,,,,`,`,`,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,`,,~,,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,`,`,`,,,,`,`,`,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,`,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,~,,`,`,`,,~,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,~,,~,,~,,~,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,~,,~,,~,,~,,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,`,,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1),,T{pets=true}(1x1) +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` + +#build label(crypt_extended_build) start(18; 18; central stairs) hidden() message(Remember to enqueue manager orders for this blueprint.) build more urns + +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,n,,n,,n,,n,,`,,n,,n,,n,,n,,n +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,n,,n,,n,,n,,`,,n,,n,,n,,n,,n +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,n,,n,,n,,n,,`,,n,,n,,n,,n,,n +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,n,,n,,n,,n,,`,,n,,n,,n,,n,,n +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,~,,~,,~,,~,,`,,n,,n,,n,,n,,n +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,~,,~,,~,,~,,`,,n,,n,,n,,n,,n +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,~,,`,~,`,,~,,`,,n,,n,,n,,n,,n +,`,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,`,`,`,,,,`,`,`,`,,n,,n,,n,,n,,n +,,,,,,,,,,,,`,`,~,`,,~,,`,~,`,` +,,n,,n,,n,,n,,n,,`,`,`,`,,,,`,`,`,`,,n,,n,,n,,n,,n +,`,`,`,`,`,`,`,`,`,`,`,`,,,,`,`,`,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,~,,`,~,`,,~,,`,,n,,n,,n,,n,,n +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,~,,~,,~,,~,,`,,n,,n,,n,,n,,n +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,~,,~,,~,,~,,`,,n,,n,,n,,n,,n +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,n,,n,,n,,n,,`,,n,,n,,n,,n,,n +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,n,,n,,n,,n,,`,,n,,n,,n,,n,,n +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,n,,n,,n,,n,,`,,n,,n,,n,,n,,n +,`,`,`,`,`,`,`,`,`,`,`,`,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,`,` +,,n,,n,,n,,n,,n,,`,,n,,n,,n,,n,,`,,n,,n,,n,,n,,n +,,,,,,,,,,,,`,`,`,`,`,`,`,`,`,`,` diff --git a/data/blueprints/embark.csv b/data/blueprints/embark.csv new file mode 100644 index 0000000000..a92c328398 --- /dev/null +++ b/data/blueprints/embark.csv @@ -0,0 +1,17 @@ +#build label(workshops) start(8;2;center of wagon) basic post embark workshops +`,` ,`,`,` ,`,~,~,~,`,` ,`,`,` ,`,# +`,wc,`,`,wt,`,~,~,~,`,wm,`,`,wr,`,# +`,` ,`,`,` ,`,~,~,~,`,` ,`,`,` ,`,# +#,# ,#,#,# ,#,#,#,#,#,# ,#,#,# ,#,# +#place label(stockpiles) basic post embark stockpiles +w(5x10), , , , ,s(5x1) , , , , ,p(5x1), , , , ,# + , , , , ,g(5x4) , , , , ,d(5x1), , , , ,# + , , , , , , , , , ,f(5x3), , , , ,# + , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , ,# + , , , , ,u(10x5), , , , , , , , , ,# + , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , ,# +# ,#,#,#,#,# ,#,#,#,#,# ,#,#,#,#,# diff --git a/data/blueprints/exploratory-mining/connected-mineshafts.csv b/data/blueprints/exploratory-mining/connected-mineshafts.csv new file mode 100644 index 0000000000..3b4d71de2e --- /dev/null +++ b/data/blueprints/exploratory-mining/connected-mineshafts.csv @@ -0,0 +1,43 @@ +#dig diagonal interconnecting tunnels with stairs at intersections +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d,# + ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,# + , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , ,# + , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , ,# + , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , ,# + , , , , ,i, , , , , , , , , ,i, , , , , , , , , ,i, , , , , , , , , ,i, , , , , ,# + , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , ,# + , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , ,# + , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , ,# + ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,# +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d,# + ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,# + , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , ,# + , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , ,# + , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , ,# + , , , , ,i, , , , , , , , , ,i, , , , , , , , , ,i, , , , , , , , , ,i, , , , , ,# + , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , ,# + , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , ,# + , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , ,# + ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,# +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d,# + ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,# + , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , ,# + , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , ,# + , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , ,# + , , , , ,i, , , , , , , , , ,i, , , , , , , , , ,i, , , , , , , , , ,i, , , , , ,# + , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , ,# + , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , ,# + , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , ,# + ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,# +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d,# + ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,# + , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , ,# + , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , ,# + , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , ,# + , , , , ,i, , , , , , , , , ,i, , , , , , , , , ,i, , , , , , , , , ,i, , , , , ,# + , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , ,# + , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , ,# + , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , , ,d, , , , , ,d, , ,# + ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,d, , , , , , , ,d, ,# +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d,# +#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,# diff --git a/data/blueprints/exploratory-mining/tunnels.csv b/data/blueprints/exploratory-mining/tunnels.csv new file mode 100644 index 0000000000..4af994edec --- /dev/null +++ b/data/blueprints/exploratory-mining/tunnels.csv @@ -0,0 +1,52 @@ +#dig paths every 10 units +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d, , , , , , , , , ,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d diff --git a/data/blueprints/exploratory-mining/vertical-mineshafts.csv b/data/blueprints/exploratory-mining/vertical-mineshafts.csv new file mode 100644 index 0000000000..28b4de5631 --- /dev/null +++ b/data/blueprints/exploratory-mining/vertical-mineshafts.csv @@ -0,0 +1,42 @@ +#dig mineshafts as stairs every 3rd tile +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# + , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,# +i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,i, , ,# +#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,# diff --git a/data/blueprints/layout-helpers/mark_down_left.csv b/data/blueprints/layout-helpers/mark_down_left.csv new file mode 100644 index 0000000000..84732ccf6c --- /dev/null +++ b/data/blueprints/layout-helpers/mark_down_left.csv @@ -0,0 +1,201 @@ +#dig start(200;1) marks a diagonal line down and left starting at the cursor +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,md +,,,,,,,,,,,,,md +,,,,,,,,,,,,md +,,,,,,,,,,,md +,,,,,,,,,,md +,,,,,,,,,md +,,,,,,,,md +,,,,,,,md +,,,,,,md +,,,,,md +,,,,md +,,,md +,,md +,md +md diff --git a/data/blueprints/layout-helpers/mark_down_right.csv b/data/blueprints/layout-helpers/mark_down_right.csv new file mode 100644 index 0000000000..07f6ae1d08 --- /dev/null +++ b/data/blueprints/layout-helpers/mark_down_right.csv @@ -0,0 +1,201 @@ +#dig start(1;1) marks a diagonal line down and right starting at the cursor +md +,md +,,md +,,,md +,,,,md +,,,,,md +,,,,,,md +,,,,,,,md +,,,,,,,,md +,,,,,,,,,md +,,,,,,,,,,md +,,,,,,,,,,,md +,,,,,,,,,,,,md +,,,,,,,,,,,,,md +,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md diff --git a/data/blueprints/layout-helpers/mark_up_left.csv b/data/blueprints/layout-helpers/mark_up_left.csv new file mode 100644 index 0000000000..a029136cd0 --- /dev/null +++ b/data/blueprints/layout-helpers/mark_up_left.csv @@ -0,0 +1,201 @@ +#dig start(200;200) marks a diagonal line up and left starting at the cursor +md +,md +,,md +,,,md +,,,,md +,,,,,md +,,,,,,md +,,,,,,,md +,,,,,,,,md +,,,,,,,,,md +,,,,,,,,,,md +,,,,,,,,,,,md +,,,,,,,,,,,,md +,,,,,,,,,,,,,md +,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md diff --git a/data/blueprints/layout-helpers/mark_up_right.csv b/data/blueprints/layout-helpers/mark_up_right.csv new file mode 100644 index 0000000000..8f2697d621 --- /dev/null +++ b/data/blueprints/layout-helpers/mark_up_right.csv @@ -0,0 +1,201 @@ +#dig start(1;200) marks a diagonal line up and right starting at the cursor +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,,md +,,,,,,,,,,,,,,md +,,,,,,,,,,,,,md +,,,,,,,,,,,,md +,,,,,,,,,,,md +,,,,,,,,,,md +,,,,,,,,,md +,,,,,,,,md +,,,,,,,md +,,,,,,md +,,,,,md +,,,,md +,,,md +,,md +,md +md diff --git a/data/blueprints/pump_stack.csv b/data/blueprints/pump_stack.csv new file mode 100644 index 0000000000..14ac78a37c --- /dev/null +++ b/data/blueprints/pump_stack.csv @@ -0,0 +1,80 @@ +#notes label(help) +A pump stack is useful for moving water or magma up through the z-levels. +"" +"1) Select the ""/dig"" blueprint and position the blueprint preview on the bottom level of the future pump stack. It should be on the z-level just above the liquid you want to pump." +"" +"2) Enable repetitions with the ""r"" hotkey (ensure you're repeating Up z-levels, not Down) and lock the blueprint in place with the ""L"" hotkey. Move up the z-levels to check that the pump stack has a clear path and doesn't intersect with any open areas (e.g. caverns). Increase the number of repetitions with the ""+"" or ""*"" hotkeys if you need the pump stack to extend further up. Unlock the blueprint and shift it around if you need to, then lock it again to recheck the vertical path." +"" +"3) If you need to flip the pump stack around to make it fit through the rock layers, enable transformations with the ""t"" hotkey and rotate/flip the blueprint as necessary." +"" +"4) Once you have everything lined up, hit Enter to apply. If the height ends up being one too many at the top, manually undesignate the top level." +"" +"5) Since the bottom up/down staircase is a liability, erase the Up/Down staircase designation on the lowest level and replace it with an Up staircase designation. Otherwise you might get water (or magma) critters climbing up through your access stairway!" +"" +"6) After the stack is dug out, haul away (or dump) any stones that are in the way of building the pumps." +"" +"7) Load up the ""/channel"" blueprint and apply it with the same repetition and transformation settings that you used for the ""/dig"" blueprint. Unless you have restarted DF, gui/quickfort will have saved your settings." +"" +"8) Since you do not need to transmit power down below the lowest level, erase the channel designation on the middle tile of the bottom-most pump stack level." +"" +"9) After the channels are dug, prepare for building by setting the buildingplan plugin material filters for screw pumps. If you are planning to move magma, be sure to select magma-safe materials (like green glass) for all three components of the screw pump." +"" +"10) Finally, generate orders for (the ""o"" hotkey) and run the ""/build"" blueprint with the same repetition and transformation settings that you used for the other blueprints. As you manufacture the materials you need to construct the screw pumps, your dwarves will build the pump stack from the bottom up, ensuring each new screw pump is properly supported by the one below." +"" +"If your dwarves end up building the pumps out of order, a section of the stack may spontaneously deconstruct. This will reduce the efficiency of the stack a little, but it's nothing to worry about. Just re-run the ""/build"" blueprint over the entire stack to ""fix up"" any broken pieces. The blueprint will harmlessly skip over any correctly-built screw pumps." +"" +See the wiki for more info on pump stacks: https://dwarffortresswiki.org/index.php/Screw_pump#Pump_stack +#dig label(digSN) start(2;4;on access stairs) hidden() for a pump from south level + +,,,mwmdd +,,,mwmdd +,mwmdi,mwmdd,mwmdd +,,,mwmdd + +#dig label(digNS) start(2;4;on access stairs) hidden() for a pump from north level + +,,,mwmdd +,mwmdd,mwmdd,mwmdd +,mwmdi,,mwmdd +,,,mwmdd + +#meta label(dig) start(at the bottom level on the access stairs) 2 levels of pump stack - bottom level pumps from the south +/digSN +#< +/digNS +#dig label(channelSN) start(2;4;on access stairs) hidden() for a pump from south level + +,,,` +,,,h +,~,`,` +,,,h + +#dig label(channelNS) start(2;4;on access stairs) hidden() for a pump from north level + +,,,h +,`,`,` +,~,,h +,,,` + +#meta label(channel) start(at the bottom level on the access stairs) 2 levels of pump stack - bottom level pumps from the south +/channelSN +#< +/channelNS +#build label(buildSN) start(2;4;on access stairs) hidden() for a pump from south level + +,,,` +,,,~ +,`,`,Msm +,,,` + +#build label(buildNS) start(2;4;on access stairs) hidden() for a pump from north level + +,,,` +,`,`,~ +,`,,Msu +,,,` + +#meta label(build) start(at the bottom level on the access stairs) 2 levels of pump stack - bottom level pumps from the south +/buildSN +#< +/buildNS diff --git a/data/blueprints/test/ecosystem/golden/meta-1-dig.csv b/data/blueprints/test/ecosystem/golden/meta-1-dig.csv new file mode 100644 index 0000000000..456d2ba92e --- /dev/null +++ b/data/blueprints/test/ecosystem/golden/meta-1-dig.csv @@ -0,0 +1,72 @@ +#dig label(dig) start(3;3) +d,d,,,d +d,,j,,d +d,u,d,u,d +d,,j +d,,,d,d +#> +d,d,d,d,d +,,u,,d +,j,d,j +d,,u +d,,d,d,d +#> +d,d,,,d +d,,j,,d +d,u,d,u,d +d,,j +d,,,d,d +#> +d,d,d,d,d +,,u,,d +,j,d,j +d,,u +d,,d,d,d +#> +d,d,,,d +d,,j,,d +d,u,d,u,d +d,,j +d,,,d,d +#> +d,d,d,d,d +,,u,,d +,j,d,j +d,,u +d,,d,d,d +#> +d,d,,,d +d,,j,,d +d,u,d,u,d +d,,j +d,,,d,d +#> +d,d,d,d,d +,,u,,d +,j,d,j +d,,u +d,,d,d,d +#> +d,d,,,d +d,,j,,d +d,u,d,u,d +d,,j +d,,,d,d +#> +d,d,d,d,d +,,u,,d +,j,d,j +d,,u +d,,d,d,d +#> +d,d,,,d +d,,j,,d +d,u,d,u,d +d,,j +d,,,d,d +#> +d,d,d,d,d +,,u,,d +,j,d,j +d,,u +d,,d,d,d diff --git a/data/blueprints/test/ecosystem/golden/tracks-2-carve.csv b/data/blueprints/test/ecosystem/golden/tracks-2-carve.csv new file mode 100644 index 0000000000..c5b4309612 --- /dev/null +++ b/data/blueprints/test/ecosystem/golden/tracks-2-carve.csv @@ -0,0 +1,6 @@ +#dig label(carve) +trackSE,trackEW,trackEW,trackEW,trackSW +trackNE,,,,trackNW +#> + +,trackrampEW,trackEW,trackrampEW diff --git a/data/blueprints/test/ecosystem/golden/transform-1-dig.csv b/data/blueprints/test/ecosystem/golden/transform-1-dig.csv new file mode 100644 index 0000000000..b26339d8a4 --- /dev/null +++ b/data/blueprints/test/ecosystem/golden/transform-1-dig.csv @@ -0,0 +1,28 @@ +#dig label(dig) start(14;14) +,d,d,,d,d,d,,d,d,d,d,d,,d,d,d,d,d,,d,d,d,,d,d +d,,d,,d,d,d,,d,d,d,d,d,,d,d,d,d,d,,d,d,d,,d,,d +d,d,,,d,d,d,,d,d,d,d,d,,d,d,d,d,d,,d,d,d,,,d,d +,,,,,,,,d,d,d,d,d,,d,d,d,d,d +d,d,d,,,d,d,,d,d,d,d,d,,d,d,d,d,d,,d,d,,,d,d,d +d,d,d,,d,,d,,d,d,d,d,d,,d,d,d,d,d,,d,,d,,d,d,d +d,d,d,,d,d,,,d,d,d,d,d,,d,d,d,d,d,,,d,d,,d,d,d +,,,,,,,,d,d,d,d,d,,d,d,d,d,d +d,d,d,d,d,d,d,d,,,,,,,,,,,,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,,,d,d,d,,d,d,d,,,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,,d,,d,d,,d,d,,d,,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,,d,d,,d,,d,,d,d,,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,,d,d,d,,,,d,d,d,,d,d,d,d,d,d,d,d + +d,d,d,d,d,d,d,d,,d,d,d,,,,d,d,d,,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,,d,d,,d,,d,,d,d,,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,,d,,d,d,,d,d,,d,,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,,,d,d,d,,d,d,d,,,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,,,,,,,,,,,,d,d,d,d,d,d,d,d +,,,,,,,,d,d,d,d,d,,d,d,d,d,d +d,d,d,,d,d,,,d,d,d,d,d,,d,d,d,d,d,,,d,d,,d,d,d +d,d,d,,d,,d,,d,d,d,d,d,,d,d,d,d,d,,d,,d,,d,d,d +d,d,d,,,d,d,,d,d,d,d,d,,d,d,d,d,d,,d,d,,,d,d,d +,,,,,,,,d,d,d,d,d,,d,d,d,d,d +d,d,,,d,d,d,,d,d,d,d,d,,d,d,d,d,d,,d,d,d,,,d,d +d,,d,,d,d,d,,d,d,d,d,d,,d,d,d,d,d,,d,d,d,,d,,d +,d,d,,d,d,d,,d,d,d,d,d,,d,d,d,d,d,,d,d,d,,d,d diff --git a/data/blueprints/test/ecosystem/golden/transform-2-construct.csv b/data/blueprints/test/ecosystem/golden/transform-2-construct.csv new file mode 100644 index 0000000000..9620c96c12 --- /dev/null +++ b/data/blueprints/test/ecosystem/golden/transform-2-construct.csv @@ -0,0 +1,28 @@ +#build label(construct) start(14;14) +,trackNS,trackE,,trackW,trackS,trackN,,,,,,,,,,,,,,trackN,trackS,trackE,,trackW,trackNS +trackEW,,trackSE,,trackSW,trackNE,trackNW,,,,,,,,,,,,,,trackNE,trackNW,trackSE,,trackSW,,trackEW +trackS,trackSE,,,trackNSE,trackNSW,trackEW,,,,,,,,,,,,,,trackEW,trackNSE,trackNSW,,,trackSW,trackS + +trackN,trackNE,trackSEW,,,trackSEW,trackNEW,,,,,,,,,,,,,,trackNEW,trackSEW,,,trackSEW,trackNW,trackN +trackE,trackSW,trackNEW,,trackNSE,,trackNSEW,,,,,,,,,,,,,,trackNSEW,,trackNSW,,trackNEW,trackSE,trackW +trackW,trackNW,trackNS,,trackNSW,trackNSEW,,,,,,,,,,,,,,,,trackNSEW,trackNSE,,trackNS,trackNE,trackE + + +,,,,,,,,,,trackrampNW,trackrampNS,trackrampN,,trackrampN,trackrampNS,trackrampNE +,,,,,,,,,trackrampNW,,trackrampNSE,trackrampNSW,,trackrampNSE,trackrampNSW,,trackrampNE +,,,,,,,,,trackrampEW,trackrampSEW,,trackrampNSEW,,trackrampNSEW,,trackrampSEW,trackrampEW +,,,,,,,,,trackrampW,trackrampNEW,trackrampNSEW,,,,trackrampNSEW,trackrampNEW,trackrampE + +,,,,,,,,,trackrampW,trackrampSEW,trackrampNSEW,,,,trackrampNSEW,trackrampSEW,trackrampE +,,,,,,,,,trackrampEW,trackrampNEW,,trackrampNSEW,,trackrampNSEW,,trackrampNEW,trackrampEW +,,,,,,,,,trackrampSW,,trackrampNSE,trackrampNSW,,trackrampNSE,trackrampNSW,,trackrampSE +,,,,,,,,,,trackrampSW,trackrampNS,trackrampS,,trackrampS,trackrampNS,trackrampSE + + +trackW,trackSW,trackNS,,trackNSW,trackNSEW,,,,,,,,,,,,,,,,trackNSEW,trackNSE,,trackNS,trackSE,trackE +trackE,trackNW,trackSEW,,trackNSE,,trackNSEW,,,,,,,,,,,,,,trackNSEW,,trackNSW,,trackSEW,trackNE,trackW +trackS,trackSE,trackNEW,,,trackNEW,trackSEW,,,,,,,,,,,,,,trackSEW,trackNEW,,,trackNEW,trackSW,trackS + +trackN,trackNE,,,trackNSE,trackNSW,trackEW,,,,,,,,,,,,,,trackEW,trackNSE,trackNSW,,,trackNW,trackN +trackEW,,trackNE,,trackNW,trackSE,trackSW,,,,,,,,,,,,,,trackSE,trackSW,trackNE,,trackNW,,trackEW +,trackNS,trackE,,trackW,trackN,trackS,,,,,,,,,,,,,,trackS,trackN,trackE,,trackW,trackNS diff --git a/data/blueprints/test/ecosystem/golden/transform-3-build.csv b/data/blueprints/test/ecosystem/golden/transform-3-build.csv new file mode 100644 index 0000000000..74434544ab --- /dev/null +++ b/data/blueprints/test/ecosystem/golden/transform-3-build.csv @@ -0,0 +1,28 @@ +#build label(build) start(14;14) +,~,~,,~,~,~,,gs(1x2),ga(2x1),,gx(1x2),gw(1x2),,gw(1x2),gx(1x2),gd(2x1),,gs(1x2),,~,~,~,,~,~ +~,,~,,~,~,~,,,gd(2x1),,,,,,,ga(2x1),,,,~,~,~,,~,,~ +~,~,,,~,~,~,,Mrsssqq(2x1),,,Msh,,,,,Msk,Mrsqq(2x1),,,~,~,~,,,~,~ +,,,,,,,,CSdddaaaa,,Msk,,Mw,,Mw,,,Msh,CSddddaaaa +~,~,~,,,~,~,,CSa,,Mrss(1x2),Mw,,,,Mw,Mrss(1x2),,CSa,,~,~,,,~,~,~ +~,~,~,,~,,~,,,Msm,,,Mhs(1x2),,Mhs(1x2),,,Msm,,,~,,~,,~,~,~ +~,~,~,,~,~,,,Msu,,Mws,,,,,,Mws,,Msu,,,~,~,,~,~,~ +,,,,,,,,,Mws,,Mh(2x1),,,Mh(2x1),,,Mws +gs(2x1),,Mrqq(1x2),CSddaaaa,CSa,,Msh,,,,,,,,,,,,,,,Msk,CSa,CSddaaaa,Mrqq(1x2),gs(2x1) +gw(1x2),gx(1x2),,,,Msk,,Mw,,,~,~,~,,~,~,~,,,Mw,,,Msh,,,gx(1x2),gw(1x2) +,,,Msm,Mrs(2x1),,Mw,,,~,,~,~,,~,~,,~,,,Mw,Mrsss(2x1),,Msm +gd(2x1),,Msu,,Mws,,,Mhs(1x2),,~,~,,~,,~,,~,~,,Mhs(1x2),,,Mws,,Msu,ga(2x1) +ga(2x1),,,Mws,,Mh(2x1),,,,~,~,~,,,,~,~,~,,,Mh(2x1),,,Mws,,gd(2x1) + +ga(2x1),,,Mws,,Mh(2x1),,Mhs(1x2),,~,~,~,,,,~,~,~,,Mhs(1x2),Mh(2x1),,,Mws,,gd(2x1) +gd(2x1),,,,Mws,,,,,~,~,,~,,~,,~,~,,,,,Mws,,,ga(2x1) +gx(1x2),gw(1x2),Msm,,Mrs(2x1),,Mw,,,~,,~,~,,~,~,,~,,,Mw,Mrsss(2x1),,,Msm,gw(1x2),gx(1x2) +,,Mrssqq(1x2),Msu,,Msk,,Mw,,,~,~,~,,~,~,~,,,Mw,,,Msh,Msu,Mrssqq(1x2) +gs(2x1),,,CSdaaaa,CSa,,Msh,,,,,,,,,,,,,,,Msk,CSa,CSdaaaa,,gs(2x1) +,,,,,,,,,Mws,,Mh(2x1),,,Mh(2x1),,,Mws +~,~,~,,~,~,,,,,Mws,,Mhs(1x2),,Mhs(1x2),,Mws,,,,,~,~,,~,~,~ +~,~,~,,~,,~,,Msm,,Mr(1x2),,,,,,Mr(1x2),,Msm,,~,,~,,~,~,~ +~,~,~,,,~,~,,CSa,Msu,,Mw,,,,Mw,,Msu,CSa,,~,~,,,~,~,~ +,,,,,,,,CSdddaaaa,,Msk,,Mw,,Mw,,,Msh,CSddddaaaa +~,~,,,~,~,~,,Mrsssqq(2x1),,,Msh,,,,,Msk,Mrsqq(2x1),,,~,~,~,,,~,~ +~,,~,,~,~,~,,gs(1x2),gd(2x1),,gw(1x2),gx(1x2),,gx(1x2),gw(1x2),ga(2x1),,gs(1x2),,~,~,~,,~,,~ +,~,~,,~,~,~,,,ga(2x1),,,,,,,gd(2x1),,,,~,~,~,,~,~ diff --git a/data/blueprints/test/ecosystem/in/basic-1-dig.csv b/data/blueprints/test/ecosystem/in/basic-1-dig.csv new file mode 100644 index 0000000000..a2019b675a --- /dev/null +++ b/data/blueprints/test/ecosystem/in/basic-1-dig.csv @@ -0,0 +1,6 @@ +#dig label(dig) +,,d +,d,d,d +d,d,d,d,d +,d,d,d +,,d diff --git a/data/blueprints/test/ecosystem/in/basic-2-carve.csv b/data/blueprints/test/ecosystem/in/basic-2-carve.csv new file mode 100644 index 0000000000..250ea23812 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/basic-2-carve.csv @@ -0,0 +1,6 @@ +#dig label(carve) +,,trackS +,,trackNS +trackE,trackEW,trackNSEW,trackEW,trackW +,,trackNS +,,trackN diff --git a/data/blueprints/test/ecosystem/in/basic-3-build.csv b/data/blueprints/test/ecosystem/in/basic-3-build.csv new file mode 100644 index 0000000000..c69caf7133 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/basic-3-build.csv @@ -0,0 +1,5 @@ +#build label(build) + + + +,h,,f diff --git a/data/blueprints/test/ecosystem/in/basic-4-place.csv b/data/blueprints/test/ecosystem/in/basic-4-place.csv new file mode 100644 index 0000000000..754fd30228 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/basic-4-place.csv @@ -0,0 +1,3 @@ +#place label(place) + +,f,,g diff --git a/data/blueprints/test/ecosystem/in/basic-5-zone.csv b/data/blueprints/test/ecosystem/in/basic-5-zone.csv new file mode 100644 index 0000000000..83042e20ec --- /dev/null +++ b/data/blueprints/test/ecosystem/in/basic-5-zone.csv @@ -0,0 +1,4 @@ +#zone label(zone) +,,m +,m,m,m +,pPf(2x2) diff --git a/data/blueprints/test/ecosystem/in/basic-spec.csv b/data/blueprints/test/ecosystem/in/basic-spec.csv new file mode 100644 index 0000000000..828b2ca964 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/basic-spec.csv @@ -0,0 +1,4 @@ +#notes +description=basic test for all phases +width=5 +height=5 diff --git a/data/blueprints/test/ecosystem/in/buildings-1-dig.csv b/data/blueprints/test/ecosystem/in/buildings-1-dig.csv new file mode 100644 index 0000000000..0731112b65 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/buildings-1-dig.csv @@ -0,0 +1,43 @@ +#dig label(dig) +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +h,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d +#> + + + + + + + +r diff --git a/data/blueprints/test/ecosystem/in/buildings-2-construct.csv b/data/blueprints/test/ecosystem/in/buildings-2-construct.csv new file mode 100644 index 0000000000..e7e1d12bbc --- /dev/null +++ b/data/blueprints/test/ecosystem/in/buildings-2-construct.csv @@ -0,0 +1,21 @@ +#build label(construct) + + + + + + + + + + + + + +Cw +Cf +Cr +Cu +Cd +Cx +CF diff --git a/data/blueprints/test/ecosystem/in/buildings-3-build.csv b/data/blueprints/test/ecosystem/in/buildings-3-build.csv new file mode 100644 index 0000000000..f48457c0a5 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/buildings-3-build.csv @@ -0,0 +1,33 @@ +#build label(build) +a,Mg,,CS +b,Mh(1x1),S,CSa,,,,,,Mw,,,wm,,,wp +c,Mhs(1x1),m,CSaa,,,,,,,,,,,,,,,,,D +n,Mv,v,CSaaa,,Msu +,Mr(1x1),j,CSaaaa,,,,,,Mws,,,wu,,,ew +d,Mrq(1x1),A,CSd,,,Msk +,Mrqq(1x1),R,CSda +l,Mrqqq(1x1),N,CSdaa,,Msm,,,,we,,,wn,,,es,,,,,k +x,Mrqqqq(1x1),~h,CSdaaa +H,Mrs(1x1),~a,CSdaaaa,,,Msh +W,Mrsq(1x1),~c,CSdd,,,,,,wq,,,wr,,,el +G,Mrsqq(1x1),F,CSdda +B,Mrsqqq(1x1),o(1x1),CSddaa,,,,,,,,,,,,,,,,,ws +~,~b,Mrsqqqq(1x1),CSddaaa,,,,,,wM,,,wt,,,eg +~,f,Mrss(1x1),CSddaaaa +~,h,Mrssq(1x1),CSddd +~,r,Mrssqq(1x1),CSddda,,,,,,wo,,,wl,,,ea,,,,gx(1x2),gx(1x2) +~,s,Mrssqqq(1x1),CSdddaa +~,~s,Mrssqqqq(1x1),CSdddaaa,,,,,,,,,,,,,,gd(2x1),,gs(2x1),,ga(2x1) +~,t,Mrsss(1x1),CSdddaaaa,,,,,,wk,,,ww,,,ek,,gd(2x1),,gs(2x1),,ga(2x1) +gs(1x1),Mrsssq(1x1),,CSdddd,,,,,,,,,,,,,,,,gw(1x2),gw(1x2) +ga(1x1),Mrsssqq(1x1),,CSdddda +gd(1x1),Mrsssqqq(1x1),,CSddddaa,,,,,,wb,,,wz,,,en +gw(1x1),Mrsssqqqq(1x1),,CSddddaaa,,,,,,,,,,,,,,Mh(2x1),,Mh(2x1),,Mhs(1x2),Mhs(1x2) +gx(1x1),,,CSddddaaaa,,,,,,,,,,,,,,Mh(2x1),,Mh(2x1) +,,,Ts,,,,,,wc,,,wh,,,ib,,Mr(1x2),Mr(1x2),Mrs(2x1),,Mhs(1x2),Mhs(1x2) +y,,,Tw,,,,,,,,,,,,,,,,Mrs(2x1) +Y,,,Tl,,,,,,,,,,,,,,Mr(1x2),Mr(1x2),Mrsq(2x1),,Mrsq(2x1) +,,,Tp,,,,,,wf,,,wy,,,ic,,,,Mrsssqqqq(2x1),,Mrsssqqqq(2x1) +,,,Tc +,,,TS +,,,,,,,,,,wv,,,wd,,,wj,,,wS diff --git a/data/blueprints/test/ecosystem/in/buildings-spec.csv b/data/blueprints/test/ecosystem/in/buildings-spec.csv new file mode 100644 index 0000000000..dd74099f3c --- /dev/null +++ b/data/blueprints/test/ecosystem/in/buildings-spec.csv @@ -0,0 +1,8 @@ +#notes +description=underground buildings coverage test +width=24 +height=37 +depth=2 +#ignore +does not include (p) farm plots or (oO) dirt/paved roads, since they are built +on dirt and the ecosystem harness only chooses rock areas. diff --git a/data/blueprints/test/ecosystem/in/fortifications-1-dig.csv b/data/blueprints/test/ecosystem/in/fortifications-1-dig.csv new file mode 100644 index 0000000000..dc40f07b26 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/fortifications-1-dig.csv @@ -0,0 +1,3 @@ +#dig label(dig) + +,d diff --git a/data/blueprints/test/ecosystem/in/fortifications-2-smooth.csv b/data/blueprints/test/ecosystem/in/fortifications-2-smooth.csv new file mode 100644 index 0000000000..bf91a23287 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/fortifications-2-smooth.csv @@ -0,0 +1,4 @@ +#dig label(smooth) +,s +s,,s +,s diff --git a/data/blueprints/test/ecosystem/in/fortifications-3-carve.csv b/data/blueprints/test/ecosystem/in/fortifications-3-carve.csv new file mode 100644 index 0000000000..c174cc918a --- /dev/null +++ b/data/blueprints/test/ecosystem/in/fortifications-3-carve.csv @@ -0,0 +1,4 @@ +#dig label(carve) +,F +F,,F +,F diff --git a/data/blueprints/test/ecosystem/in/fortifications-spec.csv b/data/blueprints/test/ecosystem/in/fortifications-spec.csv new file mode 100644 index 0000000000..462a2e6dbe --- /dev/null +++ b/data/blueprints/test/ecosystem/in/fortifications-spec.csv @@ -0,0 +1,4 @@ +#notes +description=test carving fortifications +width=3 +height=3 diff --git a/data/blueprints/test/ecosystem/in/meta-1-dig.csv b/data/blueprints/test/ecosystem/in/meta-1-dig.csv new file mode 100644 index 0000000000..7467bca2d5 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/meta-1-dig.csv @@ -0,0 +1,41 @@ +#ignore +tests recursive meta composition, z-level manipulation, transformations, and +repeat up/down + +#dig label(border) start(3 3) hidden() +d(2x1),,,,d(1x3) + + + +d(1x-4),,,,d(-2x1) +#dig label(center_tile) start(3 3) hidden() + + +,,d +#dig label(even_up) start(3 3) hidden() + + +,u,,u +#dig label(even_down) start(3 3) hidden() + +,,j + +,,j +#meta label(even) hidden() +/border +/even_up +/even_down +#meta label(odd) hidden() +/even transform(rotcw) +#meta label(twoz) hidden() +/even +#> +/odd +#meta label(fourz) hidden() +/twoz +#>2 +/twoz +#> +/center_tile repeat(up 4) +#meta label(dig) +/fourz repeat(>3) diff --git a/data/blueprints/test/ecosystem/in/meta-spec.csv b/data/blueprints/test/ecosystem/in/meta-spec.csv new file mode 100644 index 0000000000..5b32a29384 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/meta-spec.csv @@ -0,0 +1,6 @@ +#notes +description=meta coverage test +width=5 +height=5 +depth=12 +"start=3,3" diff --git a/data/blueprints/test/ecosystem/in/stockpiles-2-place.csv b/data/blueprints/test/ecosystem/in/stockpiles-2-place.csv new file mode 100644 index 0000000000..f5ac0ce511 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/stockpiles-2-place.csv @@ -0,0 +1,12 @@ +#place label(place) +a(2x2),,f(2x2),,u(2x2),,n(2x2),,y(2x2),,r(2x2) + +s(2x2),,w(2x2),,e(2x2),,b(2x2),,h(2x2),,l(2x2) + +z(2x2),,S(2x2),,g(2x2),,p(2x2),,d(2x2),,afunyrswebhlzSgpd(2x2) + +a,a,g,g,a,,,g,l,w,s,a +a,,,g,a,a,g,g,w,w,s,a +u,u,u,,,,,,s,s,s,a +u,z,u,,,c,,,a,a,a,a +u,u,u diff --git a/data/blueprints/test/ecosystem/in/stockpiles-spec.csv b/data/blueprints/test/ecosystem/in/stockpiles-spec.csv new file mode 100644 index 0000000000..f0fb680be9 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/stockpiles-spec.csv @@ -0,0 +1,4 @@ +#notes +description=stockpile coverage test +width=12 +height=11 diff --git a/data/blueprints/test/ecosystem/in/tracks-1-dig.csv b/data/blueprints/test/ecosystem/in/tracks-1-dig.csv new file mode 100644 index 0000000000..734ecd0b7c --- /dev/null +++ b/data/blueprints/test/ecosystem/in/tracks-1-dig.csv @@ -0,0 +1,6 @@ +#dig label(dig) +d,d,d,d,d +d,h,,h,d +#> + +,r,d,r diff --git a/data/blueprints/test/ecosystem/in/tracks-2-carve.csv b/data/blueprints/test/ecosystem/in/tracks-2-carve.csv new file mode 100644 index 0000000000..0646e5934d --- /dev/null +++ b/data/blueprints/test/ecosystem/in/tracks-2-carve.csv @@ -0,0 +1,6 @@ +#dig label(carve) +T(5x2) +,,,,T(-5x-2) +#> + +T(5x1) diff --git a/data/blueprints/test/ecosystem/in/tracks-3-build.csv b/data/blueprints/test/ecosystem/in/tracks-3-build.csv new file mode 100644 index 0000000000..c750936b44 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/tracks-3-build.csv @@ -0,0 +1,4 @@ +#build label(build) +#> + +,,CS diff --git a/data/blueprints/test/ecosystem/in/tracks-spec.csv b/data/blueprints/test/ecosystem/in/tracks-spec.csv new file mode 100644 index 0000000000..c0dc9526ad --- /dev/null +++ b/data/blueprints/test/ecosystem/in/tracks-spec.csv @@ -0,0 +1,5 @@ +#notes +description=track coverage test +width=5 +height=2 +depth=2 diff --git a/data/blueprints/test/ecosystem/in/transform-1-dig.csv b/data/blueprints/test/ecosystem/in/transform-1-dig.csv new file mode 100644 index 0000000000..92d386e551 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/transform-1-dig.csv @@ -0,0 +1,26 @@ +#dig label(big) hidden() +d(5x8) +#dig label(outer) hidden() +d,d,d,,d,d +d,d,d,,d +d,d,d + +d,d +d +#dig label(inner) hidden() +d,d,d +d,d +d +#meta label(chunk) hidden() +/big shift(1 -13) +/outer shift(7 -13) +/inner shift(1 -4) +#meta label(dig) +/chunk +/chunk transform(cw) +/chunk transform(cw cw) +/chunk transform(ccw) +/chunk transform(fliph) +/chunk transform(flipv) +/chunk transform(cw flipv) +/chunk transform(ccw flipv) diff --git a/data/blueprints/test/ecosystem/in/transform-2-construct.csv b/data/blueprints/test/ecosystem/in/transform-2-construct.csv new file mode 100644 index 0000000000..95717afa85 --- /dev/null +++ b/data/blueprints/test/ecosystem/in/transform-2-construct.csv @@ -0,0 +1,23 @@ +#build label(outer) hidden() +trackN,trackS,trackE,,trackW,trackNS +trackNE,trackNW,trackSE,,trackSW +trackEW,trackNSE,trackNSW + +trackNEW,trackSEW +trackNSEW +#build label(inner) hidden() +trackrampN,trackrampNS,trackrampNE +trackrampNSE,trackrampNSW +trackrampNSEW +#meta label(chunk) hidden() +/outer shift(7 -13) +/inner shift(1 -4) +#meta label(construct) +/chunk +/chunk transform(cw) +/chunk transform(cw cw) +/chunk transform(ccw) +/chunk transform(fliph) +/chunk transform(flipv) +/chunk transform(cw flipv) +/chunk transform(ccw flipv) diff --git a/data/blueprints/test/ecosystem/in/transform-3-build.csv b/data/blueprints/test/ecosystem/in/transform-3-build.csv new file mode 100644 index 0000000000..7907220e7c --- /dev/null +++ b/data/blueprints/test/ecosystem/in/transform-3-build.csv @@ -0,0 +1,20 @@ +#build label(big) hidden() +gw(1x2),gx(1x2),gd(2x1),,gs(1x2) +,,ga(2x1) +,,Msk,Mrsqq(2x1) +Mw,,,Msh,CSddddaaaa +,Mw,Mrss(1x2),,CSa +Mhs(1x2),,,Msm +,,Mws,,Msu +Mh(2x1),,,Mws +#meta label(chunk) hidden() +/big shift(1 -13) +#meta label(build) +/chunk +/chunk transform(cw) +/chunk transform(cw cw) +/chunk transform(ccw) +/chunk transform(fliph) +/chunk transform(flipv) +/chunk transform(cw flipv) +/chunk transform(ccw flipv) diff --git a/data/blueprints/test/ecosystem/in/transform-spec.csv b/data/blueprints/test/ecosystem/in/transform-spec.csv new file mode 100644 index 0000000000..2a3bba25fe --- /dev/null +++ b/data/blueprints/test/ecosystem/in/transform-spec.csv @@ -0,0 +1,5 @@ +#notes +description=transformation coverage test +width=27 +height=27 +"start=14,14" diff --git a/data/blueprints/test/ecosystem/in/zones-2-zone.csv b/data/blueprints/test/ecosystem/in/zones-2-zone.csv new file mode 100644 index 0000000000..b67a1dd5bf --- /dev/null +++ b/data/blueprints/test/ecosystem/in/zones-2-zone.csv @@ -0,0 +1,8 @@ +#zone label(zone) +w(1x1),f(1x1),g(1x1),d(1x1),n(1x1) +p(1x1),s(1x1),c(1x1),m(1x1),h(1x1) +t(1x1),a(1x1) +n(1x1),n(1x1) +wfgGt^dpPf^scmhH{hospital thread=90000 cloth=60000 splints=6 crutches=6 plaster=15000 buckets=3 soap=900}^t(2x2) + +hH{hospital splints=6}(1x1) diff --git a/data/blueprints/test/ecosystem/in/zones-spec.csv b/data/blueprints/test/ecosystem/in/zones-spec.csv new file mode 100644 index 0000000000..37d6dfedcd --- /dev/null +++ b/data/blueprints/test/ecosystem/in/zones-spec.csv @@ -0,0 +1,4 @@ +#notes +description=zone coverage test +width=5 +height=7 diff --git a/data/blueprints/test/quickfort/list/all_modes.csv b/data/blueprints/test/quickfort/list/all_modes.csv new file mode 100644 index 0000000000..c8a042846a --- /dev/null +++ b/data/blueprints/test/quickfort/list/all_modes.csv @@ -0,0 +1,10 @@ +#dig hidden() +#build hidden() +#place hidden() +#zone hidden() +#query hidden() +#config hidden() +#ignore +#aliases +#meta hidden() +#notes hidden() diff --git a/data/blueprints/test/quickfort/list/all_modes_separate_sheets.xlsx b/data/blueprints/test/quickfort/list/all_modes_separate_sheets.xlsx new file mode 100644 index 0000000000..47445283f0 Binary files /dev/null and b/data/blueprints/test/quickfort/list/all_modes_separate_sheets.xlsx differ diff --git a/data/blueprints/test/quickfort/list/all_modes_single_sheet.xlsx b/data/blueprints/test/quickfort/list/all_modes_single_sheet.xlsx new file mode 100644 index 0000000000..51331918c1 Binary files /dev/null and b/data/blueprints/test/quickfort/list/all_modes_single_sheet.xlsx differ diff --git a/data/blueprints/tombs/Mini_Saracen.csv b/data/blueprints/tombs/Mini_Saracen.csv new file mode 100644 index 0000000000..f30fbc55da --- /dev/null +++ b/data/blueprints/tombs/Mini_Saracen.csv @@ -0,0 +1,26 @@ +#dig start(6;6) room for 24 corpses +d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d,d,d, ,d, ,d,# + , , , ,d,d,d, , , , ,# +d, ,d,d,i,i,i,d,d, ,d,# +d,d,d,d,i,i,i,d,d,d,d,# +d, ,d,d,i,i,i,d,d, ,d,# + , , , ,d,d,d, , , , ,# +d, ,d, ,d,d,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d,# +#,#,#,#,#,#,#,#,#,#,#,# +#build label(urns) start(6;6) message(use burial script to mark urns as usable) 24 urns +n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,`,`,`, ,n, ,n,# + , , , ,`,`,`, , , , ,# +n, ,`,`,~,~,~,`,`, ,n,# +`,`,`,`,~,~,~,`,`,`,`,# +n, ,`,`,~,~,~,`,`, ,n,# + , , , ,`,`,`, , , , ,# +n, ,n, ,`,`,`, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n,# +#,#,#,#,#,#,#,#,#,#,#,# diff --git a/data/blueprints/tombs/The_Saracen_Crypts.csv b/data/blueprints/tombs/The_Saracen_Crypts.csv new file mode 100644 index 0000000000..a70b77a09a --- /dev/null +++ b/data/blueprints/tombs/The_Saracen_Crypts.csv @@ -0,0 +1,99 @@ +#dig start(24;25) room for 513 corpses +# see an image of this blueprint at https://i.imgur.com/Kcjvx6R.png +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,d,d,d,d,d,d,d,d,d,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,d,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , ,d,d,d, , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,d,d,d,i,i,i,d,d,d,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,i,i,i,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,d,d,d,i,i,i,d,d,d,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , ,d,d,d, , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,d,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# + , , , , , , , , , , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , , , , , , , , , , ,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d, , , , , , , , , ,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,# +d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,d,d,d,d,d,d,d,d,d,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d, ,d,# +#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,# +#build label(urns) start(24;24) message(use burial script to mark urns as usable) 513 urns +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`,`,`,`,`,`,`,`,`,`,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n,`,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , ,`,`,`, , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`,`,`,`,~,~,~,`,`,`,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,~,~,~,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`,`,`,`,~,~,~,`,`,`,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , ,`,`,`, , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n,`,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# + , , , , , , , , , , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , , , , , , , , , , ,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`, , , , , , , , , ,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,`,# +n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,`,`,`,`,`,`,`,`,`,`, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n, ,n,# +#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,# diff --git a/data/dfhack-config/autonick.txt b/data/dfhack-config/autonick.txt new file mode 100644 index 0000000000..bdd40beed4 --- /dev/null +++ b/data/dfhack-config/autonick.txt @@ -0,0 +1,1283 @@ +# autonick config file +# every line in this file that is not empty and does +# not start with "#" will be used as a nickname by the +# autonick script. + +# nicknames can be multiple words +Toady One +Threetoe + +#Dwarven single names taken from Classic Fantasy works +Balin +Dwalin +Fili +Kili +Gloin +Oin +Bifur +Bofur +Bombur +Ori +Gimli +Thrain +Thror +Fundin +Frerin +Gror +Ibun +Khim +Fimbrethil +Floi +Nali +Thor +Vili +Regin +Fafnir +Brokkr +Sindri +Nordri +Sudri +Austri +Doriath +Thingol +Eol +Mim +Telchar +Narvi +Gundabad +Muhrak +Skorri +Draupnir +Alaric +Grimr +Eitri +Svidurr +Thorgar +Hrungnir +Galar +Skirni +Hreinn +Dori +Hreimr +Hreinir +Hroaldr +Groin +Vestri +Nori +Durin +Dvalin +Eikinskjaldi +Bafur +Snorri +Fimafeng +Vitr +Dvali +Dain +Nain +Nipingr +Hrodvitnir +Sveinn +Ivaldi +Svein +Sveinbjorn +Havardr +Haki +Hakon +Mouri +Motsognir +Eberk +Thromar +Kragar +Borgar +Throk +Orvald +Berric +Rogar +Urgen +Morgrim +Keldar +Ingvar +Frandar +Grimsi +Hrokur +Orik +Rundar +Bjornar +Throki +Dworin +Thranduil +Faldar +Galdor +Thorkel +Dorrin +Borkan +Gundrik +Throkir +Raldor +Helgrim +Throgar +Borin +Ragnir +Orvar +Skalf +Baldir +Fror +Thorgil +Ulfar +Grimbold +Faldur +Varrin +Dornir +Halgrim +Gundin +Ulfgar +Skalfar +Yngvarr +Kaldur +Thrandar +Keldin +Rundin +Skaldur +Borgin +Haldur +Bjornulf +Orkarn +Ragnor +Baldrick +Thorlin +Graldor +Ulfrik +Fornir +Egil +Grimnor +Roldor +Ulfgard +Borgrim +Faldrik +Rognir +Balfor +Volmar +Thormund +Brynhild + +#Dwarven composite names taken from Classic Fantasy works +Gorin Stonehammer +Brundar Ironfoot +Haldrek Battlebeard +Orin Stonefist +Frida Stormaxe +Torvald Rockjaw +Einar Blackforge +Thorgar Granitebeard +Ragnir Hammerhelm +Hilda Ironbrow +Grimnar Deepdelver +Ulfrik Ironmane +Freya Thunderstone +Ragnar Firebeard +Gunnar Ironpeak +Astrid Ironheart +Bjorn Steelbreaker +Hrolf Thunderhammer +Sigrun Stonebreaker +Eirik Rockbeard +Helga Frostbeard +Skaldur Stormguard +Agnar Stonehand +Ingrid Mountainmace +Hjalmar Blackstone +Solveig Steelhelm +Rurik Stonegrip +Freyja Silveraxe +Thordur Goldbeard +Gudrun Ironfoot +Vali Fireforge +Thora Frostbeard +Vargr Stoneborn +Astrid Ironbrow +Einar Blackstone +Hilda Hammerheart +Leif Ironshaper +Thrain Stormbrow +Sigrid Steelheart +Haldor Boulderbreaker +Ragnhild Strongarm +Brynjar Ironmantle +Sigrun Thunderbeard +Valgard Steelbeard +Gunnhild Stonefist +Ingrid Ironrock +Eirik Frostbane +Helga Deepforge +Skaldur Ironshield +Agnar Stonemace +Solveig Stormgrip +Hjalmar Mountainheart +Gudrun Firebeard +Thora Thunderstrike +Vargr Ironhand +Freyja Stoneguard +Thordur Blackstone +Rurik Hammerbeard +Solveig Ironbreaker +Astrid Goldhand +Einar Stormbrew +Hilda Steelbeard +Thrain Ironmane +Sigrid Fireheart +Haldor Thunderstone +Ragnhild Ironfoot +Brynjar Blackhelm +Sigrun Frostbeard +Valgard Stoneshield +Gunnhild Ironheart +Bjorn Deepdelver +Ingrid Ironpeak +Eirik Thunderhammer +Gormund Stoneforge +Eovar Broadshield +Thrunir Hammerstone +Brunhild Steelbraid +Garrik Frostbeard +Haldrek Ironhand +Astrid Rockrider +Dagmar Stonefury +Borgar Thunderhelm +Ingrid Ironstrike +Rurik Blackmane +Fjorn Stoneborn +Siv Ironbreaker +Gudrik Stormbeard +Ulfgar Emberforge +Eilif Silverstone +Hilda Stormwarden +Ormar Ironjaw +Vali Steelshaper +Eira Frostbeard +Torgar Graniteheart +Brunhild Firebrand +Haldrek Ironmantle +Solveig Rockbreaker +Thrain Thunderaxe +Brynjar Stoneclaw +Asa Ironhide +Grimnar Blackmane +Ragnvald Hammerfall +Gudbrand Ironhand +Astrid Flamebeard +Ormur Steelbender +Hjalmar Rockjaw +Inga Thunderheart +Valgard Ironbeard +Eirik Swiftstrike +Sylvi Stoneguard +Helge Hammerfist +Jorunn Fireforge +Solveig Ironroot +Thora Stormbeard +Baldur Stonemane +Freydis Ironshaper +Gunnvald Deepstone +Bjorn Blackstone +Ingrid Frostmane +Agnar Steelhammer +Thordur Ironbeard +Ylva Goldhand +Greta Firestone +Rurik Rockhelm +Gunnhild Ironsong +Vali Steelgrip +Brynhild Stormblade +Astrid Ironmantle +Einar Stoneshield +Hilda Frostbeard +Ormr Ironheart +Inga Steelbreaker +Ulfrik Thunderaxe +Freyja Stonebeard +Sigrun Frostfury +Sylvi Blackmane +Thorvald Ironhelm +Eirik Stormstone +Haldora Deepdelver +Sigrid Steelshaper +Gunnar Thunderheart +Bjorn Ironbrow +Ingrid Goldmantle +Agnar Stormforge +Solveig Ironclaw +Thora Rockguard +Grimur Emberstone +Ragnhild Hammerstrike +Vali Ironfist +Brynjar Blackbraid +Astrid Flameforge +Einar Stonestorm +Hilda Frostbane +Ormur Ironhelm +Inga Steelshaper +Gudbrand Thunderbeard +Freya Stonefist +Gunnvald Stormmane +Bjorn Ironhelm +Ingrid Frostforge +Agnar Steelgrip +Thordur Ironhand +Ylva Flameheart +Greta Stonemane +Rurik Ironroot +Gunnhild Steelbeard +Vali Thunderstrike +Thorin Oakenshield +Dain Ironfoot +Gamil Zirak + + +# animals +Mouse +Otter +Snake +Owl +Bat +Fox +Mole +Cat +Badger +Squirrel +Kit +Wren +Jay +Crow +Raven +Sparrow +Platypus +House Mouse +Pangolin +Funnel Web +Weasel +Meerkats +Rat +Ant +Gopher +Fennec +Groundhog +Aardvark +Rabbit +Olm +Chipmunk +Bilbie +Vole +Nile Croc +Wombat +Worm +Gerbil +Armodillo +Thrinaxodon +Binky +Bandicoot +Bettongs +Potoroos +Antechinus +Jerboas +Numbat + +# colours +Flash +Red +Gray +Blue +Shadow +Indigo +Jade +Silver +Bistre +Black +Black bean +Noir +Charcoal +Ebony +Eerie +Jet +Licorice +Midnight +Night +Onyx +Space +Raisin +Rich +Russ violet +Smoky +Aero +Alice +Argent Lue +Azure +Azul +Baby blue +Berkeley +Bice +Bleu +Bondi +Brandeis Byzant +Cambridge +Carolina +Celestial +Celtic +Cerulean +Chefchaouen +Chrysler +Cobalt +Columbia +Cornflower +Delft +Denim +Dodger +Duke +Federal +Electrindigo +Eclipse +Illini +Klein +Jordy +Lapis Lazuli +Majorelle +Marian +Maya +Slate +Munsell +Navy +Neon blue +Oxford +Palatinate +Penn +Periwinkle +Phthalo +Picton +Poly +Powder +Prussia +Royal +Ruddy +Honolulu +Savoy +Silver Lake +Space cadet +Steel +Tang +Tufts +Ultramarine +Uranian +Vista +Yale +Zaffre +Auburn +Almond +Beaver +Beige +Bole +Bone +Bronze +Sienna +Umber +Camel +Caput mortuum +Caramel +Chamoisee +Chestnut +Chocolate +Citron +Cocoa +Coffee +Copper +Coyote +Desert +Drab +Dun +Earth +Fallow +Fawn +Field +Fulvous +Goldenrod +Harvest +Khaki +Kobicha +Lion +Liver +Mahogany +Maroon +Ochre +Redwood +Rufous +Russet +Rust +Sand +Satin +Sheen +Seal +Sepia +Sinopia +Tan +Tawny +Van Dyke +Walnut +Wenge +Aqua +Aquamarine +Capri +Caribbean +Celeste +Cyprus +Fluorescent +Jungle +Keppel +Ice +Sea +Myrtle +Pacific +Robin +Skobeloff +Teal +Verdigris +Vivid +Zomp +Platinum +Timberwolf +Rose quartz +Cinereous +Cadet +Cool +Davys +Paynes +Glaucous +Gunmetal +Feldgrau +Asparagus +Avocado +Brunswick +Cal Poly +Castleton +Celadon +Chartreuse +Moss +Pastel +Dartmouth +Emerald +Fern +Forest +Harlequin +Honeydew +Hunter +Kelly green +Lawn +Malachite +Mantis +Neon +Olivine +Paris +Pear +Pigment +Pistachio +Reseda +Rifle +Sage +Screamin' +Shamrock +Bud +Amaranth +Baker-Miller +Cerise +Carmine +Magenta +Eggplant +Fandango +Finn +Fuchsia +Haze +Plum +Pizzazz +Quinacridone +Razzle dazzle +Rose +Shocking +Telemagenta +Aerospace +Alloy +Amber +Atomic +Tangerine +Burnt +Butterscotch +Carrot +Champagne +Coral +Flame +Gold +Hunyadi +Melon +Peel +Papaya +Peach +Persimmon +Princeton +Pumpkin +Safety orange +Saffron +Tangelo +Tigers Eye +Titian +Xanthous +Blush +Brilliant +Brink +Carnation +Cherry +Cyclamen +Dogwood +Hollywood +Hot +Lavender +Mimi +Misty +Mountbatten +Orchid +Phlox +Pompadour +Puce +Raspberry +Razzmatazz +Bonbon +Quartz +Taupe +Vale +Rosewood +Rosy +Salmon +Tea +Tickle +Thulian +Ultra +Burgundy +Byzantium +Eminence +Grape +Iris +Mardi Gras +Mauve +Mauveine +Mulberry +Murrey +Pale +Pomp +Power +Purpureus +Tekhelet +Thistle +Tropical +Tyrian +Wisteria +Barn +Bittersweet +Shimmer +Blood +Candy apple +Cantaloupe +Cardinal +Chili +Cosmos +Cinnabar +Claret +Coquelicot +Cordovan +Cornell +Crimson +Falu +Brick +Engine +Folly +Imperial +Jaspar +Poppy +Rojo +Rusty +Scarlet +Syracuse +Tomato +Turkey +Vermilion +Wine +Alabaster +Antique +Cornsilk +Latte +Cream +Eggshell +Flax +Floral +Ghost +Isabelline +Ivory +Lemon +chiffon +Linen +Navajo +Nyanza +Lace +Parchment +Pearl +Seasalt +Seashell +Vanilla +Smoke +Apricot +Arylide +Aureolin +Buff +Canary +Ecru +Gamboge +Icterine +Jonquil +Maize +Mikado +Mindaro +Mustard +Selective +Stil de grain +Straw +Sunglow +Sunset +Wheat + +# planets +Mars +Jupiter +Saturn +Pluto +Neptune +Europa + +# charites +Damia +Auxesia +Cleta +Phaenna +Hegemone +Peitho +Paregoros +Pasithea +Charis +Kale +Antheia +Eudaimonia +Euthymia +Eutychia +Paidia +Pandaisia +Pannychis +Aglaea +Euphrosyne +Thalia + +# nature +Blaze +River +Snow +Bones +Rain +Reed +Lake +Briar +Brook +Sky +Storm +Clay +Ember +Marsh +Star + +# trees +Ash +Oak +Rowan +Aspen +Alder +Apple +Beech +Birch +Box +Cedar +Cypress +Elder +Elm +Larch +Fir +Juniper +Lime +Pine +Poplar +Spruce +Yew + +# seasons +Spring +Summer +Autumn +Winter + +# cardinals +North +South +East +West + +# other +Ink +Echo +Mint +Mel +X +Sam +Tango +Gadget +Brum +Wall +Beam +Ud +Tal +Ren +Aki +Jun +Kei +Lynn +Lex +Cid +Miles +Rotor +Mesa +Verse + +# from the "300 list" +Aiden +Arden +Auden +August +Avery +Avis +Bay +Blake +Erin +Ezra +Kai +Lane +Leah +Noel +Pat +Ray +Remi +Roan +Robyn +Salem +Sean +Tate +Tobin +Tori +True +Val +Wilder +Wisdom +Wyatt +Zephyr + +# Gemstones +Actinolite +Nephrite +Adamite +Aegirine +Afghanite +Agrellite +Algodonite +Alunite +Amblygonite +Analcime +Anatase +Andalusite +Chiastolite +Anglesite +Anhydrite +Annabergite +Anorthite +Antigorite +Bowenite +Apatite +Apophyllite +Aragonite +Asbestos +Astrophyllite +Augelite +Austinite +Ferro +Magnes +Mangan +Tinzenite +Azurmalachite +Azurite +Baryte +Bast +Bayldonite +Benitoite +Beryl +Maxixe +Goshenite +Golden beryl +Heliodor +Morganite +Red beryl +Beryllonite +Beudantite +Bismutot +Biotit +Boracite +Bornite +Brazilianite +Brookite +Brucite +Bustam +Bytown +Calcite +Caledonite +Canasite +Cancrin +Vishnev +Carleton +Carnall +Cassiterite +Cataplei +Cavans +Celestite +Ceruleite +Cerussite +Chalcopyr +Chambers +Charlesite +Charoite +Childrenite +Chiolite +Chrysoberyl +Alexandrite +Cymophane +Chromite +Chrysocolla +Clinochlore +Clinohumite +Clintonite +Cobaltite +Coleman +Cordierite +Iolite +Cornwallite +Corundum +Ruby +Sapphire +Padparadscha +Covell +Creedite +Crocite +Cuprite +Danburite +Datolite +Descloiz +Diamond +Bort +Ballas +Diaspore +Dickinsonite +Diopside +Dioptase +Dolomite +Dumortier +Ekanite +Trapiche +Enstatite +Bronzite +Hypersthene +Eosphorite +Epidote +Piemont +Erythrite +Esperite +Ettring +Eudialyte +Faya +Feldspar +Andesine +Albite +Anorth +Anorthoc +Amazon +Celsian +Microcline +Moonstone +Adularia +Rainbow +Ortho +Kite +Plagioclase +Labradorite +Oligoclase +Sunstone +Oregon Sunstone +Rainbow Lattice +Fergusonite +Ferroaxin +Fluora +Fluorapophyl +Fluorite +Forster +Friedelite +Gadolin +Gahnite +Gahnospinel +Garnet +Pyralspite +Almandine +Spessartine +Ugrand +Demantoid +Melanite +Topazolita +Grossular +Hessonite +Hydrogrossular +Tsavorite +Pyrope +Rhodolite +Mali garnet +Malaia +Umbal +Gaspe +Gayluss +Gibbsite +Glaucophane +Goeth +Goosecreek +Grandidier +Gypsum +Gyro +Halite +Hambergite +Hanksite +Hardystonite +Helenite +Hematite +Herder +Hexagonite +Hibonite +Hidden +Hodgkinsonite +Holtite +Howlite +Huebnerite +Humite +Hurlbut +Ilmenite +Inderite +Jadeite +Jasper +Jeremejevite +Kainite +Kämmerer +Kaolin +Kornerup +Kurnakov +Kyanite +Langbein +Lawsonite +Lazulite +Lazurite +Legrandite +Lepidolite +Leucite +Leucophan +Linarite +Lizardite +Londonite +Ludlamite +Ludwigite +Maria-meionite +Werner +Marcasite +Meliphanite +Mellite +Mesolite +Milar +Millerite +Mime +Monazite +Mordenite +Mottram +Muscovite +Fuchsite +Nambul +Natrolite +Nepheline +Neptunite +Nickeline +Niccolite +Nosean +Nuumm +Opal +Fire opal +Moss opal +Painite +Papagoite +Pargas +Parisite +Pectol +Larimar +Pentland +Periclase +Perthite +Petal +Castor +Pezzottaite +Phena +Phosgen +Phospho +Piemontite +Realgar +Rhodizite +Rhodochros +Rhodon +Richter +Riebeck +Crocidolite +Rosasite +Rutile +Samarskite +Sanidine +Sapphirine +Sarcol +Scapol +Marialite +Meionite +Scheel +Schizol +Scorod +Selenite +Sella +Senarmon +Sepio +Meerschaum +Sérandite +Seraph +Serendibite +Serpentine +Bowen +Stich +Shattuck +Shiga +Shortite +Shung +Siderite +Silliman +Simpsonite +Sinhal +Smalt +Smithsonite +Sodalite +Hackman +Sogdian +Sperry +Spessar +Sphaler +Spinel +Ceylon +Spodumene +Triphane +Spurrite +Stauro +Strontian +Titanate +Sulfur +Bustamite +Sylvite +Taaffeita +Talc +Tantalite +Tektites +Tephroite +Thomsonite +Thaumasite +Topaz +Tourmaline +Achroite +Chrome +Dravite +Elbaite +Indicol +Olenite +Paraiba +Rossman +Rubellite +Tremol +Triphyl +Triplite +Tugtup +Turquoise +Ulex +Ussing +Vanadinite +Variscite +Vesuvianite +Californite +Villiaum +Vivianite +Vlasov +Wardite +Wavell +Welogan +Whewell +Wilkeite +Willemite +Wither +Wollastone +Wulfenite +Wurtzite +Xonot +Yugawara +Zektzer +Zeolites +Chabaz +Steller +Stilbite +Zinc +Zinnwald +Zircon +Jacinth +Zoisite +Tanzan +Thulite +Zultan +Zany +Lapis lazuli +Desert glass +Llanite +Maw sit-sit +Obsidian +Tears +Pallas +Peridot +Soapstone +Tact +Unakite +Bauxite +Concretions +Bloodstone +Heliotrope +Eilat stone +Epidos +Glimmer +Goldstone +Hawks eye +Iddings +Lampro diff --git a/data/dfhack-config/blueprints/README.md b/data/dfhack-config/blueprints/README.md new file mode 100644 index 0000000000..5d0e41a245 --- /dev/null +++ b/data/dfhack-config/blueprints/README.md @@ -0,0 +1,5 @@ +This folder contains blueprints that can be applied by the `quickfort` script. For more information, see: + +* [Quickfort command reference](https://docs.dfhack.org/en/stable/docs/tools/quickfort.html) +* [Quickfort blueprint guide](https://docs.dfhack.org/en/stable/docs/guides/quickfort-user-guide.html) +* [Quickfort library guide](https://docs.dfhack.org/en/stable/docs/guides/quickfort-library-guide.html) diff --git a/data/dfhack-config/buildingplan.json b/data/dfhack-config/buildingplan.json new file mode 100644 index 0000000000..9bb3052b71 --- /dev/null +++ b/data/dfhack-config/buildingplan.json @@ -0,0 +1,5 @@ +{ + "planner": { + "minimized": true + } +} \ No newline at end of file diff --git a/dfhack-config/dfstatus.lua b/data/dfhack-config/dfstatus.lua similarity index 100% rename from dfhack-config/dfstatus.lua rename to data/dfhack-config/dfstatus.lua diff --git a/data/dfhack-config/dwarfmonitor.json b/data/dfhack-config/dwarfmonitor.json new file mode 100644 index 0000000000..9bd3b1f769 --- /dev/null +++ b/data/dfhack-config/dwarfmonitor.json @@ -0,0 +1,3 @@ +{ + "date_format": "Y-M-D" +} diff --git a/data/dfhack-config/init/default.dfhack.init b/data/dfhack-config/init/default.dfhack.init new file mode 100644 index 0000000000..aad18dd1c4 --- /dev/null +++ b/data/dfhack-config/init/default.dfhack.init @@ -0,0 +1,7 @@ +# Load DFHack defaults. +# +# If you delete this file, it will reappear when you restart DFHack. +# Instead, please comment out the following line if you do not want DFHack to +# load its default configuration. + +script hack/init/dfhack.default.init diff --git a/data/dfhack-config/init/default.onLoad.init b/data/dfhack-config/init/default.onLoad.init new file mode 100644 index 0000000000..fe87d42097 --- /dev/null +++ b/data/dfhack-config/init/default.onLoad.init @@ -0,0 +1,7 @@ +# Load DFHack defaults. +# +# If you delete this file, it will reappear when you restart DFHack. +# Instead, please comment out the following line if you do not want DFHack to +# load its default configuration. + +script hack/init/onLoad.default.init diff --git a/data/dfhack-config/init/default.onMapLoad.init b/data/dfhack-config/init/default.onMapLoad.init new file mode 100644 index 0000000000..9e781b924a --- /dev/null +++ b/data/dfhack-config/init/default.onMapLoad.init @@ -0,0 +1,7 @@ +# Load DFHack defaults. +# +# If you delete this file, it will reappear when you restart DFHack. +# Instead, please comment out the following line if you do not want DFHack to +# load its default configuration. + +script hack/init/onMapLoad.default.init diff --git a/data/dfhack-config/init/default.onMapUnload.init b/data/dfhack-config/init/default.onMapUnload.init new file mode 100644 index 0000000000..716680fd01 --- /dev/null +++ b/data/dfhack-config/init/default.onMapUnload.init @@ -0,0 +1,7 @@ +# Load DFHack defaults. +# +# If you delete this file, it will reappear when you restart DFHack. +# Instead, please comment out the following line if you do not want DFHack to +# load its default configuration. + +script hack/init/onMapUnload.default.init diff --git a/data/dfhack-config/init/default.onUnload.init b/data/dfhack-config/init/default.onUnload.init new file mode 100644 index 0000000000..712c35098f --- /dev/null +++ b/data/dfhack-config/init/default.onUnload.init @@ -0,0 +1,7 @@ +# Load DFHack defaults. +# +# If you delete this file, it will reappear when you restart DFHack. +# Instead, please comment out the following line if you do not want DFHack to +# load its default configuration. + +script hack/init/onUnload.default.init diff --git a/data/dfhack-config/init/dfhack.init b/data/dfhack-config/init/dfhack.init new file mode 100644 index 0000000000..b05598f988 --- /dev/null +++ b/data/dfhack-config/init/dfhack.init @@ -0,0 +1,5 @@ +# This file runs when DFHack is initialized, when Dwarf Fortress is first +# started, before any world or save data is loaded. +# +# You can extend or override DFHack's default configuration by adding commands +# to this file. diff --git a/data/dfhack-config/init/onLoad.init b/data/dfhack-config/init/onLoad.init new file mode 100644 index 0000000000..ef4fd97afe --- /dev/null +++ b/data/dfhack-config/init/onLoad.init @@ -0,0 +1,6 @@ +# This file runs when a world is loaded. This happens when you open a save file +# in fort, adventure, or legends mode. If a fort is being loaded, this file runs +# before any onMapLoad.init files. +# +# You can extend or override DFHack's default configuration by adding commands +# to this file. diff --git a/data/dfhack-config/init/onMapLoad.init b/data/dfhack-config/init/onMapLoad.init new file mode 100644 index 0000000000..90c6b9e140 --- /dev/null +++ b/data/dfhack-config/init/onMapLoad.init @@ -0,0 +1,5 @@ +# This file runs when a map is loaded in adventure or fort mode, after any +# onLoad.init files (which run earlier, when the world is loaded). +# +# You can extend or override DFHack's default configuration by adding commands +# to this file. diff --git a/data/dfhack-config/init/onMapUnload.init b/data/dfhack-config/init/onMapUnload.init new file mode 100644 index 0000000000..c513d9caea --- /dev/null +++ b/data/dfhack-config/init/onMapUnload.init @@ -0,0 +1,5 @@ +# This file runs when a fortress map is unloaded, before any onUnload.init files +# (which run later, when the world is unloaded). +# +# You can extend or override DFHack's default configuration by adding commands +# to this file. diff --git a/data/dfhack-config/init/onUnload.init b/data/dfhack-config/init/onUnload.init new file mode 100644 index 0000000000..c8ed3ab5b5 --- /dev/null +++ b/data/dfhack-config/init/onUnload.init @@ -0,0 +1,4 @@ +# This file runs when a world is unloaded. +# +# You can extend or override DFHack's default configuration by adding commands +# to this file. diff --git a/dfhack-config/script-paths.txt b/data/dfhack-config/script-paths.txt similarity index 100% rename from dfhack-config/script-paths.txt rename to data/dfhack-config/script-paths.txt diff --git a/data/dfhack-config/scripts/README.md b/data/dfhack-config/scripts/README.md new file mode 100644 index 0000000000..95b67b058d --- /dev/null +++ b/data/dfhack-config/scripts/README.md @@ -0,0 +1,7 @@ +You can put scripts you write or download in this folder and DFHack will find +them. + +If a script in this directory has the same name as a default DFHack script, the + script in this directory will take precedence. + +Everything you add to this folder will be kept safe when you upgrade DFHack. diff --git a/data/dfhack-config/stockpiles/README.md b/data/dfhack-config/stockpiles/README.md new file mode 100644 index 0000000000..593d45fb67 --- /dev/null +++ b/data/dfhack-config/stockpiles/README.md @@ -0,0 +1,5 @@ +This folder contains stockpile settings that can be applied by `stockpiles` and +`quickfort` tools. For more information, see: + +* [stockpiles documentation](https://docs.dfhack.org/en/latest/docs/tools/stockpiles.html) +* [quickfort documentation](https://docs.dfhack.org/en/latest/docs/guides/quickfort-user-guide.html) diff --git a/data/init/dfhack.default.init b/data/init/dfhack.default.init new file mode 100644 index 0000000000..78dc70450a --- /dev/null +++ b/data/init/dfhack.default.init @@ -0,0 +1,8 @@ +# Default DFHack commands to run on program init + +# Please do not edit this file directly. It will be overwritten with new +# defaults when you update DFHack. Instead, add your configuration to +# dfhack-config/init/dfhack.init + +script hack/init/dfhack.keybindings.init +script hack/init/dfhack.tools.init diff --git a/data/init/dfhack.keybindings.init b/data/init/dfhack.keybindings.init new file mode 100644 index 0000000000..018c66ccde --- /dev/null +++ b/data/init/dfhack.keybindings.init @@ -0,0 +1,168 @@ +# Default DFHack keybindings + +# Please do not edit this file directly. It will be overwritten with new +# defaults when you update DFHack. Instead, add your configuration to +# dfhack-config/init/dfhack.init + +################### +# global bindings # +################### + +# the GUI command launcher (two bindings since some keyboards don't have "`") +keybinding add ` gui/launcher +keybinding add Ctrl-Shift-D gui/launcher +keybinding add Ctrl-Shift-P "gui/launcher --minimal" + +# show hotkey popup menu +keybinding add Ctrl-Shift-C hotkeys + +# control panel +keybinding add Ctrl-Shift-E gui/control-panel + +# on-screen keyboard +keybinding add Ctrl-Shift-K gui/cp437-table + +# customizable quick command list +keybinding add Ctrl-Shift-A gui/quickcmd + + +################### +# embark bindings # +################### + +keybinding add Ctrl-A@choose_start_site gui/embark-anywhere + + +################################## +# dwarfmode+dungeonmode bindings # +################################## + +# save the description of a selected unit or item to the `markdown_{YourWorldName}.md` file +# in the game root directory +keybinding add Ctrl-T@dwarfmode/ViewSheets/UNIT|dwarfmode/ViewSheets/ITEM|dungeonmode/ViewSheets/UNIT|dungeonmode/ViewSheets/ITEM markdown + +# gui/sitemap +keybinding add Ctrl-G@dwarfmode/Default|dungeonmode/Default gui/sitemap + +# toggle keyboard cursor +keybinding add Alt-K@dwarfmode|dungeonmode/Default|dungeonmode/Look toggle-kbd-cursor + +# gui/journal +keybinding add Ctrl-J@dwarfmode|dungeonmode gui/journal + + +###################### +# dwarfmode bindings # +###################### + +# quicksave +keybinding add Ctrl-Alt-S@dwarfmode quicksave + +# toggle spectate +keybinding add Ctrl-Shift-S@dwarfmode/Default "spectate toggle" + +# designate the whole vein for digging +keybinding add Ctrl-V@dwarfmode digv +keybinding add Ctrl-Shift-V@dwarfmode "digv x" + +# clean the selected tile of blood etc +keybinding add Ctrl-C@dwarfmode spotclean + +# destroy the selected item +keybinding add Ctrl-K@dwarfmode autodump-destroy-item + +# bring up the autodump UI +keybinding add Ctrl-H@dwarfmode gui/autodump + +# bring up the teleport UI +keybinding add Ctrl-Shift-T@dwarfmode gui/teleport + +# apply blueprints to the map +keybinding add Ctrl-Shift-Q@dwarfmode gui/quickfort + +# Stocks plugin +#keybinding add Ctrl-Shift-Z@dwarfmode/Default "stocks show" + +# open an overview window summarising some stocks (dfstatus) +#keybinding add Ctrl-Shift-I@dwarfmode/Default|dfhack/lua/dfstatus gui/dfstatus + +# set workorder item details (on workorder details screen press D again) +#keybinding add D@workquota_details gui/workorder-details + +# view combat reports for the selected unit/corpse/spatter +#keybinding add Ctrl-Shift-R@dwarfmode|unit|unitlist|joblist|dungeon_monsterstatus|layer_unit_relationship|item|workshop_profile|layer_noblelist|locations|pets|layer_overall_health|textviewer|reportlist|announcelist|layer_military|layer_unit_health|customize_unit|buildinglist|workshop_profile view-unit-reports + +# view extra unit information +#keybinding add Alt-I@dwarfmode/ViewUnits|unitlist gui/unit-info-viewer + +# boost priority of jobs related to the selected entity +#keybinding add Alt-N@dwarfmode|job|joblist|unit|unitlist|joblist|dungeon_monsterstatus|layer_unit_relationship|item|layer_noblelist|locations|pets|layer_overall_health|textviewer|reportlist|announcelist|layer_military|layer_unit_health|customize_unit|buildinglist|textviewer|item|layer_assigntrade|tradegoods|store|assign_display_item|treasurelist do-job-now + +# q->stockpile - copy & paste stockpiles +#keybinding add Alt-P@dwarfmode/QueryBuilding/Some/Stockpile copystock + +# q->stockpile - load and save stockpile settings out of game +#keybinding add Alt-L@dwarfmode/QueryBuilding/Some/Stockpile "gui/stockpiles -load" +#keybinding add Alt-S@dwarfmode/QueryBuilding/Some/Stockpile "gui/stockpiles -save" + +# q->workshop - duplicate the selected job +#keybinding add Ctrl-D job-duplicate + +# materials: q->workshop; b->select items +#keybinding add Shift-A "job-material ALUNITE" +#keybinding add Shift-M "job-material MICROCLINE" +#keybinding add Shift-D "job-material DACITE" +#keybinding add Shift-R "job-material RHYOLITE" +#keybinding add Shift-I "job-material CINNABAR" +#keybinding add Shift-B "job-material COBALTITE" +#keybinding add Shift-O "job-material OBSIDIAN" +#keybinding add Shift-T "job-material ORTHOCLASE" +#keybinding add Shift-G "job-material GLASS_GREEN" + +# browse rooms of same owner +#keybinding add Alt-R@dwarfmode/QueryBuilding/Some gui/room-list + +# machine power sensitive pressure plate construction +#keybinding add Ctrl-Shift-M@dwarfmode/Build/Position/Trap gui/power-meter + +# siege engine control +#keybinding add Alt-A@dwarfmode/QueryBuilding/Some/SiegeEngine gui/siege-engine + +# military weapon auto-select +#keybinding add Ctrl-W@layer_military/Equip/Customize/View gui/choose-weapons + +# military copy uniform +#keybinding add Ctrl-C@layer_military/Uniforms gui/clone-uniform + +# minecart Guide path +#keybinding add Alt-P@dwarfmode/Hauling/DefineStop/Cond/Guide gui/guide-path + +# workshop job details +#keybinding add Alt-A@dwarfmode/QueryBuilding/Some/Workshop/Job gui/workshop-job + +# workflow front-end +#keybinding add Alt-W@dwarfmode/QueryBuilding/Some/Workshop/Job gui/workflow +#keybinding add Alt-W@overallstatus "gui/workflow status" +# equivalent to the one above when gui/extended-status is enabled +#keybinding add Alt-W@dfhack/lua/status_overlay "gui/workflow status" + +# gui/rename script - rename units and buildings +#keybinding add Ctrl-Shift-N@dwarfmode|unit|unitlist|joblist|dungeon_monsterstatus|layer_unit_relationship|item|workshop_profile|layer_noblelist|locations|pets|layer_overall_health|textviewer|reportlist|announcelist|layer_military|layer_unit_health|customize_unit|buildinglist gui/rename +#keybinding add Ctrl-Shift-T@dwarfmode|unit|unitlist|joblist|dungeon_monsterstatus|layer_unit_relationship|item|workshop_profile|layer_noblelist|locations|pets|layer_overall_health|textviewer|reportlist|announcelist|layer_military|layer_unit_health|customize_unit "gui/rename unit-profession" + +# gui/design +keybinding add Ctrl-D@dwarfmode/Default gui/design +keybinding add Ctrl-M@dwarfmode/Default gui/mass-remove + + +######################## +# dungeonmode bindings # +######################## + +keybinding add Ctrl-A@setupadventure unretire-anyone + +#keybinding add Ctrl-B@dungeonmode adv-bodyswap +#keybinding add Ctrl-Shift-B@dungeonmode "adv-bodyswap force" +#keybinding add Shift-O@dungeonmode gui/companion-order +#keybinding add Ctrl-T@dungeonmode gui/advfort +keybinding add Ctrl-T@dungeonmode/Default flashstep diff --git a/data/init/dfhack.tools.init b/data/init/dfhack.tools.init new file mode 100644 index 0000000000..baa26d3ee4 --- /dev/null +++ b/data/init/dfhack.tools.init @@ -0,0 +1,19 @@ +# Default DFHack tool configuration + +# Please do not edit this file directly. It will be overwritten with new +# defaults when you update DFHack. Instead, add your configuration to +# dfhack-config/init/dfhack.init + +# Enable system services +enable buildingplan +enable burrow +enable logistics +enable overlay +enable preserve-rooms + +# aliases +alias add autounsuspend suspendmanager +alias add drain-aquifer aquifer drain --all +alias add gui/dig gui/design +alias add version help +alias add gui/pregnancy gui/family-affairs --pregnancy diff --git a/data/init/onLoad.default.init b/data/init/onLoad.default.init new file mode 100644 index 0000000000..e797f88ee7 --- /dev/null +++ b/data/init/onLoad.default.init @@ -0,0 +1,7 @@ +# Default DFHack commands to run when a world is loaded + +# Please do not edit this file directly. It will be overwritten with new +# defaults when you update DFHack. Instead, add your configuration to +# dfhack-config/init/onLoad.init + +lua require('quickfix').set_entity_race_references() diff --git a/data/init/onMapLoad.default.init b/data/init/onMapLoad.default.init new file mode 100644 index 0000000000..44986a044c --- /dev/null +++ b/data/init/onMapLoad.default.init @@ -0,0 +1,6 @@ +# Default DFHack commands to run when a map is loaded, either in +# adventure or fort mode. + +# Please do not edit this file directly. It will be overwritten with new +# defaults when you update DFHack. Instead, add your configuration to +# dfhack-config/init/onMapLoad.init diff --git a/data/init/onMapUnload.default.init b/data/init/onMapUnload.default.init new file mode 100644 index 0000000000..6441d72ffa --- /dev/null +++ b/data/init/onMapUnload.default.init @@ -0,0 +1,5 @@ +# Default DFHack commands to run when a map is unloaded + +# Please do not edit this file directly. It will be overwritten with new +# defaults when you update DFHack. Instead, add your configuration to +# dfhack-config/init/onMapUnload.init diff --git a/data/init/onUnload.default.init b/data/init/onUnload.default.init new file mode 100644 index 0000000000..9254a257bf --- /dev/null +++ b/data/init/onUnload.default.init @@ -0,0 +1,5 @@ +# Default DFHack commands to run when a world is unloaded + +# Please do not edit this file directly. It will be overwritten with new +# defaults when you update DFHack. Instead, add your configuration to +# dfhack-config/init/onUnload.init diff --git a/data/orders/basic.json b/data/orders/basic.json new file mode 100644 index 0000000000..e1cd5ac8ff --- /dev/null +++ b/data/orders/basic.json @@ -0,0 +1,1407 @@ +[ + { + "amount_left" : 10, + "amount_total" : 10, + "frequency" : "Daily", + "id" : 0, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "cookable", + "solid" + ], + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "cookable" + ], + "value" : 80 + }, + { + "condition" : "AtMost", + "flags" : + [ + "unrotten" + ], + "item_type" : "FOOD", + "value" : 2000 + } + ], + "job" : "PrepareMeal", + "meal_ingredients" : 4 + }, + { + "amount_left" : 2, + "amount_total" : 2, + "frequency" : "Daily", + "id" : 1, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten" + ], + "item_type" : "PLANT", + "reaction_product" : "DRINK_MAT", + "value" : 15 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty", + "food_storage" + ], + "value" : 5 + }, + { + "condition" : "AtMost", + "item_type" : "DRINK", + "value" : 3000 + } + ], + "job" : "CustomReaction", + "reaction" : "BREW_DRINK_FROM_PLANT" + }, + { + "amount_left" : 2, + "amount_total" : 2, + "frequency" : "Daily", + "id" : 2, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten" + ], + "item_type" : "PLANT_GROWTH", + "reaction_product" : "DRINK_MAT", + "value" : 15 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty", + "food_storage" + ], + "value" : 5 + }, + { + "condition" : "AtMost", + "item_type" : "DRINK", + "value" : 3000 + } + ], + "job" : "CustomReaction", + "reaction" : "BREW_DRINK_FROM_PLANT_GROWTH" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 4, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_pressed" + ], + "item_subtype" : "ITEM_TOOL_HONEYCOMB", + "item_type" : "TOOL", + "reaction_product" : "HONEYCOMB_PRESS_MAT", + "value" : 2 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty", + "non_absorbent" + ], + "item_type" : "TOOL", + "tool" : "LIQUID_CONTAINER", + "value" : 2 + } + ], + "job" : "CustomReaction", + "reaction" : "PRESS_HONEYCOMB" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 5, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "contains" : + [ + "honey" + ], + "reaction_id" : "MAKE_MEAD", + "value" : 2 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty", + "food_storage" + ], + "reaction_id" : "MAKE_MEAD", + "value" : 5 + } + ], + "job" : "CustomReaction", + "reaction" : "MAKE_MEAD" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 6, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "millable", + "unrotten" + ], + "item_type" : "PLANT", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty" + ], + "item_type" : "BAG", + "value" : 5 + } + ], + "job" : "MillPlants" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 7, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "processable" + ], + "item_type" : "PLANT", + "value" : 20 + } + ], + "job" : "ProcessPlants" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 8, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten" + ], + "item_type" : "PLANT", + "reaction_product" : "BAG_ITEM", + "value" : 15 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty" + ], + "item_type" : "BAG", + "value" : 5 + } + ], + "job" : "CustomReaction", + "reaction" : "PROCESS_PLANT_TO_BAG" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 9, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "processable_to_barrel" + ], + "item_type" : "PLANT", + "value" : 150 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty" + ], + "item_type" : "BARREL", + "value" : 5 + } + ], + "job" : "ProcessPlantsBarrel" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 10, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten" + ], + "item_type" : "SEEDS", + "reaction_product" : "PRESS_LIQUID_MAT", + "value" : 30 + }, + { + "condition" : "AtMost", + "flags" : + [ + "non_pressed" + ], + "item_type" : "GLOB", + "reaction_product" : "PRESS_LIQUID_MAT", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "MILL_SEEDS_NUTS_TO_PASTE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 11, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_pressed" + ], + "item_type" : "GLOB", + "reaction_product" : "PRESS_LIQUID_MAT", + "value" : 2 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty", + "non_absorbent" + ], + "item_type" : "TOOL", + "tool" : "LIQUID_CONTAINER", + "value" : 5 + }, + { + "condition" : "AtMost", + "item_type" : "LIQUID_MISC", + "reaction_product" : "SOAP_MAT", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "PRESS_OIL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 12, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "body_part", + "hair_wool" + ], + "value" : 5 + } + ], + "job" : "SpinThread", + "material_category" : + [ + "strand" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 13, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "collected", + "silk" + ], + "item_type" : "THREAD", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "silk" + ], + "item_type" : "CLOTH", + "value" : 100 + } + ], + "job" : "WeaveCloth", + "material_category" : + [ + "silk" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 14, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "collected", + "plant" + ], + "item_type" : "THREAD", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "plant" + ], + "item_type" : "CLOTH", + "value" : 100 + } + ], + "job" : "WeaveCloth", + "material_category" : + [ + "plant" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 15, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "collected", + "yarn" + ], + "item_type" : "THREAD", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "yarn" + ], + "item_type" : "CLOTH", + "value" : 100 + } + ], + "job" : "WeaveCloth", + "material_category" : + [ + "yarn" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 16, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "dyeable" + ], + "item_type" : "CLOTH", + "value" : 5 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "dye" + ], + "value" : 3 + } + ], + "job" : "DyeCloth" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 17, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 20 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_subtype" : "ITEM_TOOL_LARGE_POT", + "item_type" : "TOOL", + "value" : 25 + } + ], + "item_subtype" : "ITEM_TOOL_LARGE_POT", + "job" : "MakeTool", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 18, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 50 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_type" : "BIN", + "value" : 5 + } + ], + "job" : "ConstructBin", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 19, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 20 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_subtype" : "ITEM_TOOL_JUG", + "item_type" : "TOOL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_TOOL_JUG", + "job" : "MakeTool", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 20, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 20 + }, + { + "condition" : "AtMost", + "item_type" : "GOBLET", + "value" : 10 + } + ], + "job" : "MakeGoblet", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 21, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 150 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_WHEELBARROW", + "item_type" : "TOOL", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TOOL_WHEELBARROW", + "job" : "MakeTool", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 22, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 150 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_subtype" : "ITEM_TOOL_MINECART", + "item_type" : "TOOL", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TOOL_MINECART", + "job" : "MakeTool", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 23, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 50 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_type" : "BUCKET", + "value" : 10 + } + ], + "job" : "MakeBucket", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 24, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 150 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_type" : "CAGE", + "value" : 30 + } + ], + "job" : "MakeCage", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 25, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "TRAPPARTS", + "value" : 20 + } + ], + "job" : "ConstructMechanisms", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 26, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 10 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_type" : "BAG", + "value" : 30 + } + ], + "job" : "ConstructBag", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 27, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "silk" + ], + "item_type" : "CLOTH", + "min_dimension" : 10000, + "value" : 10 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_type" : "BAG", + "value" : 30 + } + ], + "job" : "ConstructBag", + "material_category" : + [ + "silk" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 28, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "plant" + ], + "item_type" : "CLOTH", + "min_dimension" : 10000, + "value" : 10 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_type" : "BAG", + "value" : 30 + } + ], + "job" : "ConstructBag", + "material_category" : + [ + "cloth" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 29, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "yarn" + ], + "item_type" : "CLOTH", + "min_dimension" : 10000, + "value" : 10 + }, + { + "condition" : "AtMost", + "flags" : + [ + "empty" + ], + "item_type" : "BAG", + "value" : 30 + } + ], + "job" : "ConstructBag", + "material_category" : + [ + "yarn" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 30, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "GLOB", + "reaction_class" : "WAX", + "value" : 2 + } + ], + "job" : "CustomReaction", + "reaction" : "MAKE_WAX_CRAFTS" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 31, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "shell", + "body_part" + ], + "value" : 2 + } + ], + "item_subtype" : "ITEM_PANTS_LEGGINGS", + "job" : "MakePants", + "material_category" : + [ + "shell" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 32, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "totemable", + "body_part" + ], + "value" : 5 + } + ], + "job" : "MakeTotem" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 33, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "SPLINT", + "value" : 1 + } + ], + "job" : "ConstructSplint", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 34, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "CRUTCH", + "value" : 1 + } + ], + "job" : "ConstructCrutch", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 35, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 150 + }, + { + "condition" : "AtMost", + "item_type" : "BED", + "value" : 2 + } + ], + "job" : "ConstructBed", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 36, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "ASH", + "value" : 5 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "empty" + ], + "item_type" : "BUCKET", + "value" : 5 + }, + { + "condition" : "AtMost", + "contains" : + [ + "lye" + ], + "reaction_id" : "MAKE_SOAP_FROM_TALLOW", + "value" : 5 + } + ], + "job" : "MakeLye" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 37, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten" + ], + "item_type" : "GLOB", + "reaction_class" : "TALLOW", + "reaction_product" : "SOAP_MAT", + "value" : 5 + }, + { + "condition" : "AtLeast", + "contains" : + [ + "lye" + ], + "reaction_id" : "MAKE_SOAP_FROM_TALLOW", + "value" : 3 + }, + { + "condition" : "AtMost", + "flags" : + [ + "soap" + ], + "item_type" : "BAR", + "value" : 5 + } + ], + "job" : "CustomReaction", + "reaction" : "MAKE_SOAP_FROM_TALLOW" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 38, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "LIQUID_MISC", + "reaction_product" : "SOAP_MAT", + "value" : 5 + }, + { + "condition" : "AtLeast", + "contains" : + [ + "lye" + ], + "reaction_id" : "MAKE_SOAP_FROM_OIL", + "value" : 3 + }, + { + "condition" : "AtMost", + "flags" : + [ + "soap" + ], + "item_type" : "BAR", + "value" : 5 + } + ], + "job" : "CustomReaction", + "reaction" : "MAKE_SOAP_FROM_OIL" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 39, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "ASH", + "value" : 10 + } + ], + "job" : "MakeAsh" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 40, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "ASH", + "value" : 5 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "POTASH", + "value" : 20 + } + ], + "job" : "MakePotashFromAsh" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 41, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten" + ], + "item_type" : "PLANT", + "reaction_id" : "MAKE_SLURRY_FROM_PLANT", + "reaction_product" : "PRESS_PAPER_MAT", + "value" : 50 + }, + { + "condition" : "AtMost", + "flags" : + [ + "non_pressed" + ], + "item_type" : "GLOB", + "reaction_class" : "PAPER_SLURRY", + "value" : 2 + } + ], + "job" : "CustomReaction", + "reaction" : "MAKE_SLURRY_FROM_PLANT" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 42, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_pressed" + ], + "item_type" : "GLOB", + "reaction_class" : "PAPER_SLURRY", + "reaction_id" : "PRESS_PLANT_PAPER", + "value" : 2 + }, + { + "condition" : "AtMost", + "item_type" : "SHEET", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "PRESS_PLANT_PAPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 43, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten" + ], + "item_type" : "PLANT", + "reaction_class" : "PAPER_PLANT", + "reaction_id" : "MAKE_SHEET_FROM_PLANT", + "value" : 15 + }, + { + "condition" : "AtMost", + "item_type" : "SHEET", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "MAKE_SHEET_FROM_PLANT" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 44, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_SCROLL_ROLLERS", + "item_type" : "TOOL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_TOOL_SCROLL_ROLLERS", + "job" : "MakeTool", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 45, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SHEET", + "reaction_id" : "MAKE_SCROLL", + "value" : 2 + }, + { + "condition" : "AtLeast", + "item_subtype" : "ITEM_TOOL_SCROLL_ROLLERS", + "item_type" : "TOOL", + "reaction_id" : "MAKE_SCROLL", + "value" : 2 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_SCROLL", + "item_type" : "TOOL", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "MAKE_SCROLL" + } +] diff --git a/data/orders/furnace.json b/data/orders/furnace.json new file mode 100644 index 0000000000..62e389ded1 --- /dev/null +++ b/data/orders/furnace.json @@ -0,0 +1,360 @@ +[ + { + "amount_left" : 20, + "amount_total" : 20, + "frequency" : "Daily", + "id" : 0, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "COAL", + "value" : 150 + }, + { + "condition" : "AtMost", + "item_type" : "BOULDER", + "material" : "INORGANIC:COAL_BITUMINOUS", + "value" : 10 + }, + { + "condition" : "AtMost", + "item_type" : "BOULDER", + "material" : "INORGANIC:LIGNITE", + "value" : 10 + } + ], + "job" : "MakeCharcoal" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 1, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 10 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "COAL", + "value" : 20 + } + ], + "job" : "MakeCharcoal" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 2, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:COAL_BITUMINOUS", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 5 + } + ], + "job" : "CustomReaction", + "reaction" : "BITUMINOUS_COAL_TO_COKE" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 3, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:LIGNITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 5 + } + ], + "job" : "CustomReaction", + "reaction" : "LIGNITE_TO_COKE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 5, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "POTASH", + "reaction_id" : "MAKE_PEARLASH", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "PEARLASH", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "MAKE_PEARLASH" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 6, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "empty" + ], + "item_type" : "BAG", + "value" : 10 + }, + { + "condition" : "AtMost", + "flags" : + [ + "sand_bearing" + ], + "value" : 30 + } + ], + "job" : "CollectSand" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 7, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "ROUGH", + "material" : "GLASS_GREEN", + "value" : 10 + } + ], + "job" : "MakeRawGlass", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 8, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "PEARLASH", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "ROUGH", + "material" : "GLASS_CLEAR", + "value" : 10 + } + ], + "job" : "MakeRawGlass", + "material" : "GLASS_CLEAR" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 9, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "PEARLASH", + "value" : 5 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "glass_making" + ], + "item_type" : "ROUGH", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "ROUGH", + "material" : "GLASS_CRYSTAL", + "value" : 10 + } + ], + "job" : "MakeRawGlass", + "material" : "GLASS_CRYSTAL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 10, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:RAW_ADAMANTINE", + "value" : 5 + } + ], + "job" : "ExtractMetalStrands", + "material" : "INORGANIC:RAW_ADAMANTINE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 11, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "THREAD", + "material" : "INORGANIC:ADAMANTINE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:ADAMANTINE", + "value" : 20 + } + ], + "job" : "CustomReaction", + "reaction" : "ADAMANTINE_WAFERS" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 12, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "melt_designated", + "allow_melt_dump" + ], + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + } + ], + "job" : "MeltMetalObject" + } +] diff --git a/data/orders/glassstock.json b/data/orders/glassstock.json new file mode 100644 index 0000000000..ec5ad5ec6f --- /dev/null +++ b/data/orders/glassstock.json @@ -0,0 +1,688 @@ +[ + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 0, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "ARMORSTAND", + "value" : 2 + } + ], + "job" : "ConstructArmorStand", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 1, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BLOCKS", + "material" : "GLASS_GREEN", + "value" : 2 + } + ], + "job" : "ConstructBlocks", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 2, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BOX", + "material" : "GLASS_GREEN", + "value" : 2 + } + ], + "job" : "ConstructChest", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 3, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "CABINET", + "value" : 2 + } + ], + "job" : "ConstructCabinet", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 4, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "COFFIN", + "value" : 2 + } + ], + "job" : "ConstructCoffin", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 5, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "FLOODGATE", + "value" : 2 + } + ], + "job" : "ConstructFloodgate", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 6, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "GRATE", + "value" : 2 + } + ], + "job" : "ConstructGrate", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 7, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "HATCH_COVER", + "value" : 2 + } + ], + "job" : "ConstructHatchCover", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 8, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "DOOR", + "value" : 2 + } + ], + "job" : "ConstructDoor", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 9, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "STATUE", + "value" : 2 + } + ], + "job" : "ConstructStatue", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 10, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "TABLE", + "value" : 2 + } + ], + "job" : "ConstructTable", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 11, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "CHAIR", + "value" : 2 + } + ], + "job" : "ConstructThrone", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 12, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "WEAPONRACK", + "value" : 2 + } + ], + "job" : "ConstructWeaponRack", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 13, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TRAPCOMP_ENORMOUSCORKSCREW", + "item_type" : "TRAPCOMP", + "material" : "GLASS_GREEN", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TRAPCOMP_ENORMOUSCORKSCREW", + "job" : "MakeTrapComponent", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 14, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_ALTAR", + "item_type" : "TOOL", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TOOL_ALTAR", + "job" : "MakeTool", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 15, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_BOOKCASE", + "item_type" : "TOOL", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TOOL_BOOKCASE", + "job" : "MakeTool", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 16, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_PEDESTAL", + "item_type" : "TOOL", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TOOL_PEDESTAL", + "job" : "MakeTool", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 17, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "CAGE", + "value" : 2 + } + ], + "job" : "MakeCage", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 18, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "PIPE_SECTION", + "material" : "GLASS_GREEN", + "value" : 2 + } + ], + "job" : "MakePipeSection", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 19, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "WINDOW", + "material" : "GLASS_GREEN", + "value" : 2 + } + ], + "job" : "MakeWindow", + "material" : "GLASS_GREEN" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 20, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "sand_bearing" + ], + "value" : 15 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "FLASK", + "material" : "GLASS_GREEN", + "value" : 2 + } + ], + "job" : "MakeFlask", + "material" : "GLASS_GREEN" + } +] diff --git a/data/orders/military.json b/data/orders/military.json new file mode 100644 index 0000000000..e461f0d3d7 --- /dev/null +++ b/data/orders/military.json @@ -0,0 +1,4676 @@ +[ + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 0, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 10 + }, + { + "condition" : "AtMost", + "item_type" : "BACKPACK", + "value" : 10 + } + ], + "job" : "MakeBackpack", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 1, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 10 + }, + { + "condition" : "AtMost", + "flags" : + [ + "leather" + ], + "item_type" : "FLASK", + "value" : 10 + } + ], + "job" : "MakeFlask", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 2, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 10 + }, + { + "condition" : "AtMost", + "item_type" : "QUIVER", + "value" : 10 + } + ], + "job" : "MakeQuiver", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 3, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "silk" + ], + "item_type" : "CLOTH", + "min_dimension" : 10000, + "value" : 10 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_ARMOR_CLOAK", + "item_type" : "ARMOR", + "value" : 10 + } + ], + "item_subtype" : "ITEM_ARMOR_CLOAK", + "job" : "MakeArmor", + "material_category" : + [ + "silk" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 4, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "item_type" : "WEAPON", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "job" : "MakeWeapon", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 5, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_SHIELD_SHIELD", + "item_type" : "SHIELD", + "value" : 10 + } + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "job" : "MakeShield", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 6, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 25 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_ARMOR_LEATHER", + "item_type" : "ARMOR", + "value" : 10 + } + ], + "item_subtype" : "ITEM_ARMOR_LEATHER", + "job" : "MakeArmor", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 7, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 25 + }, + { + "condition" : "AtMost", + "flags" : + [ + "leather" + ], + "item_subtype" : "ITEM_HELM_HELM", + "item_type" : "HELM", + "value" : 10 + } + ], + "item_subtype" : "ITEM_HELM_HELM", + "job" : "MakeHelm", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 8, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 25 + }, + { + "condition" : "AtMost", + "flags" : + [ + "leather" + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "item_type" : "SHOES", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "job" : "MakeShoes", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 9, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 25 + }, + { + "condition" : "AtMost", + "flags" : + [ + "leather" + ], + "item_subtype" : "ITEM_PANTS_LEGGINGS", + "item_type" : "PANTS", + "value" : 10 + } + ], + "item_subtype" : "ITEM_PANTS_LEGGINGS", + "job" : "MakePants", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 10, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "SKIN_TANNED", + "value" : 25 + }, + { + "condition" : "AtMost", + "flags" : + [ + "leather" + ], + "item_subtype" : "ITEM_GLOVES_GLOVES", + "item_type" : "GLOVES", + "value" : 20 + } + ], + "item_subtype" : "ITEM_GLOVES_GLOVES", + "job" : "MakeGloves", + "material_category" : + [ + "leather" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 11, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "unrotten", + "bone", + "body_part" + ], + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "bone" + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "item_type" : "AMMO", + "value" : 1000 + } + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "job" : "MakeAmmo", + "material_category" : + [ + "bone" + ] + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 12, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "WOOD", + "value" : 150 + }, + { + "condition" : "AtMost", + "flags" : + [ + "bone" + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "item_type" : "AMMO", + "value" : 200 + }, + { + "condition" : "AtMost", + "flags" : + [ + "plant" + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "item_type" : "AMMO", + "value" : 1000 + } + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "job" : "MakeAmmo", + "material_category" : + [ + "wood" + ] + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 13, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:CASSITERITE", + "value" : 25 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:TIN", + "value" : 20 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:CASSITERITE" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 14, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:HEMATITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 40 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:HEMATITE" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 15, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:HORN_SILVER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:HORN_SILVER" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 16, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:LIMONITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 40 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:LIMONITE" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 17, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:NATIVE_COPPER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 40 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:NATIVE_COPPER" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 18, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:NATIVE_SILVER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:NATIVE_SILVER" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 19, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:MAGNETITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 40 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:MAGNETITE" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 20, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:MALACHITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 40 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:MALACHITE" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 21, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:TETRAHEDRITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 40 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:TETRAHEDRITE" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 22, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "bearing" : "TIN", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 25 + }, + { + "bearing" : "COPPER", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 40 + } + ], + "job" : "CustomReaction", + "reaction" : "BRONZE_MAKING" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 23, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:TIN", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 40 + }, + { + "bearing" : "TIN", + "condition" : "AtMost", + "item_type" : "BOULDER", + "value" : 25 + }, + { + "bearing" : "COPPER", + "condition" : "AtMost", + "item_type" : "BOULDER", + "value" : 5 + } + ], + "job" : "CustomReaction", + "reaction" : "BRONZE_MAKING2" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 24, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:PIG_IRON", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "PIG_IRON_MAKING" + }, + { + "amount_left" : 4, + "amount_total" : 4, + "frequency" : "Daily", + "id" : 25, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:PIG_IRON", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 40 + } + ], + "job" : "CustomReaction", + "reaction" : "STEEL_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 26, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "item_type" : "AMMO", + "value" : 1000 + } + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "job" : "MakeAmmo", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 27, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "min_dimension" : 150, + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "item_type" : "AMMO", + "value" : 1000 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "job" : "MakeAmmo", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 28, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "item_type" : "AMMO", + "value" : 1000 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "job" : "MakeAmmo", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 29, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "min_dimension" : 150, + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "item_type" : "AMMO", + "value" : 1000 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + } + ], + "item_subtype" : "ITEM_AMMO_BOLTS", + "job" : "MakeAmmo", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 30, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_SHIELD_SHIELD", + "item_type" : "SHIELD", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "job" : "MakeShield", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 31, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "job" : "MakeArmor", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 32, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_HELM_HELM", + "item_type" : "HELM", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_HELM_HELM", + "job" : "MakeHelm", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 33, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_SHOES_BOOTS", + "item_type" : "SHOES", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "job" : "MakeShoes", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 34, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "item_type" : "GLOVES", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "job" : "MakeGloves", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 35, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_PANTS_GREAVES", + "item_type" : "PANTS", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "material" : "INORGANIC:STEEL", + "value" : 5 + } + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "job" : "MakePants", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 36, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "item_type" : "ARMOR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "material" : "INORGANIC:STEEL", + "value" : 5 + } + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "job" : "MakeArmor", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 37, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_WEAPON_MACE", + "item_type" : "WEAPON", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "job" : "MakeWeapon", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 38, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "item_type" : "WEAPON", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 39, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_WEAPON_SPEAR", + "item_type" : "WEAPON", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 40, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "item_type" : "WEAPON", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "job" : "MakeWeapon", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 41, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "item_type" : "WEAPON", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "job" : "MakeWeapon", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 42, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_WEAPON_PICK", + "item_type" : "WEAPON", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "job" : "MakeWeapon", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 43, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "item_type" : "WEAPON", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "job" : "MakeWeapon", + "material" : "INORGANIC:STEEL" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 44, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "job" : "MakeWeapon", + "material" : "INORGANIC:SILVER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 45, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:SILVER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 46, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "item_type" : "SHIELD", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "job" : "MakeShield", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 47, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "job" : "MakeArmor", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 48, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_HELM_HELM", + "item_type" : "HELM", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_HELM_HELM", + "job" : "MakeHelm", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 49, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "item_type" : "SHOES", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "job" : "MakeShoes", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 50, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "item_type" : "GLOVES", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "job" : "MakeGloves", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 51, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "item_type" : "PANTS", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 5 + } + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "job" : "MakePants", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 52, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "item_type" : "ARMOR", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 5 + } + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "job" : "MakeArmor", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 53, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "item_type" : "WEAPON", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "job" : "MakeWeapon", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 54, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "item_type" : "WEAPON", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 55, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 56, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "job" : "MakeWeapon", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 57, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "job" : "MakeWeapon", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 58, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + } + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "job" : "MakeWeapon", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 59, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "item_type" : "WEAPON", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "job" : "MakeWeapon", + "material" : "INORGANIC:IRON" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 74, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "item_type" : "SHIELD", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "job" : "MakeShield", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 75, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "job" : "MakeArmor", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 76, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_HELM_HELM", + "item_type" : "HELM", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_HELM_HELM", + "job" : "MakeHelm", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 77, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "item_type" : "SHOES", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "job" : "MakeShoes", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 78, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "item_type" : "GLOVES", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + } + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "job" : "MakeGloves", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 79, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "item_type" : "PANTS", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 5 + } + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "job" : "MakePants", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 80, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "item_type" : "ARMOR", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 5 + } + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "job" : "MakeArmor", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 67, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "min_dimension" : 150, + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + } + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "job" : "MakeWeapon", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 82, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "item_type" : "WEAPON", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 83, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 84, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "job" : "MakeWeapon", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 85, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "job" : "MakeWeapon", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 86, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + } + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "job" : "MakeWeapon", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 87, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "item_type" : "WEAPON", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "job" : "MakeWeapon", + "material" : "INORGANIC:BISMUTH_BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 74, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "item_type" : "SHIELD", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "job" : "MakeShield", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 75, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "job" : "MakeArmor", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 76, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_HELM_HELM", + "item_type" : "HELM", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_HELM_HELM", + "job" : "MakeHelm", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 77, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "item_type" : "SHOES", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "job" : "MakeShoes", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 78, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "item_type" : "GLOVES", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "job" : "MakeGloves", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 79, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "item_type" : "PANTS", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 5 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "job" : "MakePants", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 80, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "item_type" : "ARMOR", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 5 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "job" : "MakeArmor", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 81, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "job" : "MakeWeapon", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 82, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 83, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 84, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "job" : "MakeWeapon", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 85, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "job" : "MakeWeapon", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 86, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 30 + } + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "job" : "MakeWeapon", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 87, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 30 + } + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "job" : "MakeWeapon", + "material" : "INORGANIC:BRONZE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 88, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "item_type" : "SHIELD", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHIELD_SHIELD", + "job" : "MakeShield", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 89, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "job" : "MakeArmor", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 90, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_HELM_HELM", + "item_type" : "HELM", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_HELM_HELM", + "job" : "MakeHelm", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 91, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "item_type" : "SHOES", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_SHOES_BOOTS", + "job" : "MakeShoes", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 92, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "item_type" : "GLOVES", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + } + ], + "item_subtype" : "ITEM_GLOVES_GAUNTLETS", + "job" : "MakeGloves", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 93, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "item_type" : "PANTS", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 5 + } + ], + "item_subtype" : "ITEM_PANTS_GREAVES", + "job" : "MakePants", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 94, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 20 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "item_type" : "ARMOR", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 20 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 20 + }, + { + "condition" : "AtLeast", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_ARMOR_MAIL_SHIRT", + "item_type" : "ARMOR", + "value" : 5 + } + ], + "item_subtype" : "ITEM_ARMOR_BREASTPLATE", + "job" : "MakeArmor", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 95, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_MACE", + "job" : "MakeWeapon", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 96, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "item_type" : "WEAPON", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_HAMMER_WAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 97, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SPEAR", + "job" : "MakeWeapon", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 98, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_SWORD_SHORT", + "job" : "MakeWeapon", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 99, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "item_subtype" : "ITEM_WEAPON_AXE_BATTLE", + "job" : "MakeWeapon", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 100, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 30 + } + ], + "item_subtype" : "ITEM_WEAPON_PICK", + "job" : "MakeWeapon", + "material" : "INORGANIC:COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 101, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 30 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 30 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 30 + }, + { + "condition" : "AtMost", + "flags" : + [ + "metal" + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "item_type" : "WEAPON", + "value" : 10 + }, + { + "condition" : "LessThan", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 30 + } + ], + "item_subtype" : "ITEM_WEAPON_CROSSBOW", + "job" : "MakeWeapon", + "material" : "INORGANIC:COPPER" + } +] diff --git a/data/orders/rockstock.json b/data/orders/rockstock.json new file mode 100644 index 0000000000..db469ba398 --- /dev/null +++ b/data/orders/rockstock.json @@ -0,0 +1,502 @@ +[ + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 0, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "ARMORSTAND", + "value" : 2 + } + ], + "job" : "ConstructArmorStand", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 1, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "BLOCKS", + "value" : 20 + } + ], + "job" : "ConstructBlocks", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 2, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "CABINET", + "value" : 2 + } + ], + "job" : "ConstructCabinet", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 3, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "BOX", + "material" : "INORGANIC", + "value" : 2 + } + ], + "job" : "ConstructChest", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 4, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "COFFIN", + "value" : 2 + } + ], + "job" : "ConstructCoffin", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 5, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "DOOR", + "value" : 2 + } + ], + "job" : "ConstructDoor", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 6, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "FLOODGATE", + "value" : 2 + } + ], + "job" : "ConstructFloodgate", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 7, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "GRATE", + "value" : 2 + } + ], + "job" : "ConstructGrate", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 8, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "HATCH_COVER", + "value" : 2 + } + ], + "job" : "ConstructHatchCover", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 9, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "SLAB", + "value" : 2 + } + ], + "job" : "ConstructSlab", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 10, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "STATUE", + "value" : 2 + } + ], + "job" : "ConstructStatue", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 11, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "TABLE", + "value" : 2 + } + ], + "job" : "ConstructTable", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 12, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "CHAIR", + "value" : 2 + } + ], + "job" : "ConstructThrone", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 13, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_type" : "WEAPONRACK", + "value" : 2 + } + ], + "job" : "ConstructWeaponRack", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 14, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_ALTAR", + "item_type" : "TOOL", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TOOL_ALTAR", + "job" : "MakeTool", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 15, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_BOOKCASE", + "item_type" : "TOOL", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TOOL_BOOKCASE", + "job" : "MakeTool", + "material" : "INORGANIC" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 16, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "flags" : + [ + "non_economic", + "hard" + ], + "item_type" : "BOULDER", + "material" : "INORGANIC", + "value" : 50 + }, + { + "condition" : "AtMost", + "item_subtype" : "ITEM_TOOL_PEDESTAL", + "item_type" : "TOOL", + "value" : 2 + } + ], + "item_subtype" : "ITEM_TOOL_PEDESTAL", + "job" : "MakeTool", + "material" : "INORGANIC" + } +] diff --git a/data/orders/smelting.json b/data/orders/smelting.json new file mode 100644 index 0000000000..781a52100d --- /dev/null +++ b/data/orders/smelting.json @@ -0,0 +1,1095 @@ +[ + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 0, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:BISMUTHINITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:BISMUTHINITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 1, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:CASSITERITE", + "value" : 25 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:TIN", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:CASSITERITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 2, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:GALENA", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:LEAD", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:GALENA" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 3, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:GARNIERITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:NICKEL", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:GARNIERITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 4, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:HEMATITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:HEMATITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 5, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:HORN_SILVER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:HORN_SILVER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 6, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:LIMONITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:LIMONITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 7, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:MAGNETITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:MAGNETITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 8, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:MALACHITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:MALACHITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 9, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:NATIVE_ALUMINUM", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:ALUMINUM", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:NATIVE_ALUMINUM" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 10, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:NATIVE_COPPER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:NATIVE_COPPER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 11, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:NATIVE_GOLD", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:GOLD", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:NATIVE_GOLD" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 12, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:NATIVE_SILVER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:NATIVE_SILVER" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 13, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:NATIVE_PLATINUM", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:PLATINUM", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:NATIVE_PLATINUM" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 14, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:SPHALERITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:ZINC", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:SPHALERITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 15, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "material" : "INORGANIC:TETRAHEDRITE", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 10 + } + ], + "job" : "SmeltOre", + "material" : "INORGANIC:TETRAHEDRITE" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 16, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "bearing" : "SILVER", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 5 + }, + { + "bearing" : "COPPER", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BILLON", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "BILLON_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 17, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:TIN", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BISMUTH_BRONZE", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "BISMUTH_BRONZE_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 18, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:GOLD", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BLACK_BRONZE", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "BLACK_BRONZE_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 19, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "bearing" : "ZINC", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 5 + }, + { + "bearing" : "COPPER", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BRASS", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "BRASS_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 20, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "bearing" : "TIN", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 25 + }, + { + "bearing" : "COPPER", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "BRONZE_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 21, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:TIN", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:BRONZE", + "value" : 10 + }, + { + "bearing" : "TIN", + "condition" : "AtMost", + "item_type" : "BOULDER", + "value" : 25 + }, + { + "bearing" : "COPPER", + "condition" : "AtMost", + "item_type" : "BOULDER", + "value" : 5 + } + ], + "job" : "CustomReaction", + "reaction" : "BRONZE_MAKING2" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 22, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "bearing" : "SILVER", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 5 + }, + { + "bearing" : "GOLD", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:ELECTRUM", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "ELECTRUM_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 23, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "bearing" : "TIN", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 25 + }, + { + "bearing" : "COPPER", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 25 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:PEWTER_FINE", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "PEWTER_FINE_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 24, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:TIN", + "value" : 25 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 25 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:LEAD", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:PEWTER_LAY", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "PEWTER_LAY_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 25, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:NICKEL", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:ZINC", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:NICKEL_SILVER", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "NICKEL_SILVER_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 26, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:PIG_IRON", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "PIG_IRON_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 27, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:GOLD", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:ROSE_GOLD", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "ROSE_GOLD_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 28, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:IRON", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:PIG_IRON", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BOULDER", + "reaction_class" : "FLUX", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:STEEL", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "STEEL_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 29, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:SILVER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "INORGANIC:COPPER", + "value" : 5 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:STERLING_SILVER", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "STERLING_SILVER_MAKING" + }, + { + "amount_left" : 1, + "amount_total" : 1, + "frequency" : "Daily", + "id" : 30, + "is_active" : false, + "is_validated" : false, + "item_conditions" : + [ + { + "bearing" : "TIN", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 25 + }, + { + "bearing" : "COPPER", + "condition" : "AtLeast", + "item_type" : "BOULDER", + "value" : 25 + }, + { + "condition" : "AtLeast", + "item_type" : "BAR", + "material" : "COAL", + "value" : 100 + }, + { + "condition" : "AtMost", + "item_type" : "BAR", + "material" : "INORGANIC:PEWTER_TRIFLE", + "value" : 10 + } + ], + "job" : "CustomReaction", + "reaction" : "PEWTER_TRIFLE_MAKING" + } +] diff --git a/data/patches/README.md b/data/patches/README.md new file mode 100644 index 0000000000..599bbf47fb --- /dev/null +++ b/data/patches/README.md @@ -0,0 +1,13 @@ +Place IDA-exported `.dif` files for use by `binpatch` in subdirectories of this +directory. Each `.dif` file must be in a subdirectory named after the full +symbol table version string. For example, for DF version 51.05, you would use +these subdirectories: + +- "v0.51.05 linux64 CLASSIC" +- "v0.51.05 linux64 ITCH" +- "v0.51.05 linux64 STEAM" +- "v0.51.05 win64 CLASSIC" +- "v0.51.05 win64 ITCH" +- "v0.51.05 win64 STEAM" + +See https://docs.dfhack.org/en/stable/docs/dev/Binpatches.html for more details. diff --git a/data/professions/Chef b/data/professions/Chef new file mode 100644 index 0000000000..2dd8d8508f --- /dev/null +++ b/data/professions/Chef @@ -0,0 +1,19 @@ +NAME library/Chef +BUTCHER +TANNER +COOK +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Craftsdwarf b/data/professions/Craftsdwarf new file mode 100644 index 0000000000..5b9d03ca84 --- /dev/null +++ b/data/professions/Craftsdwarf @@ -0,0 +1,26 @@ +NAME library/Craftsdwarf +WOOD_CRAFT +STONE_CRAFT +BONE_CARVE +GLASSMAKER +EXTRACT_STRAND +POTTERY +GLAZING +WAX_WORKING +PAPERMAKING +BOOKBINDING +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Doctor b/data/professions/Doctor new file mode 100644 index 0000000000..b15ff96b22 --- /dev/null +++ b/data/professions/Doctor @@ -0,0 +1,23 @@ +NAME library/Doctor +ANIMALCARE +DIAGNOSE +SURGERY +BONE_SETTING +SUTURING +DRESSING_WOUNDS +FEED_WATER_CIVILIANS +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Farmer b/data/professions/Farmer new file mode 100644 index 0000000000..0b2801f4c2 --- /dev/null +++ b/data/professions/Farmer @@ -0,0 +1,13 @@ +NAME library/Farmer +PLANT +MILLER +BREWER +PROCESS_PLANT +MAKE_CHEESE +MILK +SHEARER +SPINNER +PRESSING +GELD +HAUL_FOOD +ALCHEMIST diff --git a/data/professions/Fisherdwarf b/data/professions/Fisherdwarf new file mode 100644 index 0000000000..6c2106e6a2 --- /dev/null +++ b/data/professions/Fisherdwarf @@ -0,0 +1,19 @@ +NAME library/Fisherdwarf +FISH +CLEAN_FISH +DISSECT_FISH +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Hauler b/data/professions/Hauler new file mode 100644 index 0000000000..36e7f400ab --- /dev/null +++ b/data/professions/Hauler @@ -0,0 +1,21 @@ +NAME library/Hauler +FEED_WATER_CIVILIANS +SIEGEOPERATE +MECHANIC +OPERATE_PUMP +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +ARCHITECT +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Laborer b/data/professions/Laborer new file mode 100644 index 0000000000..d9b9e7f498 --- /dev/null +++ b/data/professions/Laborer @@ -0,0 +1,21 @@ +NAME library/Laborer +SOAP_MAKER +BURN_WOOD +POTASH_MAKING +LYE_MAKING +SMELT +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Marksdwarf b/data/professions/Marksdwarf new file mode 100644 index 0000000000..1c9153f02f --- /dev/null +++ b/data/professions/Marksdwarf @@ -0,0 +1,17 @@ +NAME library/Marksdwarf +MECHANIC +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Mason b/data/professions/Mason new file mode 100644 index 0000000000..cd01d9a443 --- /dev/null +++ b/data/professions/Mason @@ -0,0 +1,19 @@ +NAME library/Mason +MASON +CUT_GEM +ENCRUST_GEM +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Meleedwarf b/data/professions/Meleedwarf new file mode 100644 index 0000000000..75b2196dfb --- /dev/null +++ b/data/professions/Meleedwarf @@ -0,0 +1,18 @@ +NAME library/Meleedwarf +RECOVER_WOUNDED +MECHANIC +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Migrant b/data/professions/Migrant new file mode 100644 index 0000000000..bc59555b96 --- /dev/null +++ b/data/professions/Migrant @@ -0,0 +1,21 @@ +NAME library/Migrant +FEED_WATER_CIVILIANS +SIEGEOPERATE +MECHANIC +OPERATE_PUMP +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +ARCHITECT +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Miner b/data/professions/Miner new file mode 100644 index 0000000000..3170969d94 --- /dev/null +++ b/data/professions/Miner @@ -0,0 +1,5 @@ +NAME library/Miner +MINE +DETAIL +RECOVER_WOUNDED +ALCHEMIST diff --git a/data/professions/Outdoorsdwarf b/data/professions/Outdoorsdwarf new file mode 100644 index 0000000000..2b3006fdef --- /dev/null +++ b/data/professions/Outdoorsdwarf @@ -0,0 +1,27 @@ +NAME library/Outdoorsdwarf +CARPENTER +BOWYER +CUTWOOD +ANIMALTRAIN +TRAPPER +DISSECT_VERMIN +FEED_WATER_CIVILIANS +RECOVER_WOUNDED +HERBALIST +BEEKEEPING +SIEGECRAFT +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Smith b/data/professions/Smith new file mode 100644 index 0000000000..26574f80bf --- /dev/null +++ b/data/professions/Smith @@ -0,0 +1,20 @@ +NAME library/Smith +FORGE_WEAPON +FORGE_ARMOR +FORGE_FURNITURE +METAL_CRAFT +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/StartManager b/data/professions/StartManager new file mode 100644 index 0000000000..36519bce56 --- /dev/null +++ b/data/professions/StartManager @@ -0,0 +1,57 @@ +NAME library/StartManager +CUTWOOD +ANIMALCARE +DIAGNOSE +SURGERY +BONE_SETTING +SUTURING +DRESSING_WOUNDS +FEED_WATER_CIVILIANS +BUTCHER +TANNER +DYER +SOAP_MAKER +BURN_WOOD +POTASH_MAKING +LYE_MAKING +COOK +BEEKEEPING +CLEAN_FISH +DISSECT_FISH +SMELT +FORGE_WEAPON +FORGE_ARMOR +FORGE_FURNITURE +METAL_CRAFT +LEATHER +WOOD_CRAFT +STONE_CRAFT +BONE_CARVE +GLASSMAKER +WEAVER +CLOTHESMAKER +EXTRACT_STRAND +POTTERY +GLAZING +WAX_WORKING +PAPERMAKING +BOOKBINDING +SIEGEOPERATE +MECHANIC +OPERATE_PUMP +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +ARCHITECT +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/professions/Tailor b/data/professions/Tailor new file mode 100644 index 0000000000..fc1b04bd4c --- /dev/null +++ b/data/professions/Tailor @@ -0,0 +1,20 @@ +NAME library/Tailor +DYER +LEATHER +WEAVER +CLOTHESMAKER +HAUL_STONE +HAUL_WOOD +HAUL_ITEM +HAUL_BODY +HAUL_FOOD +HAUL_REFUSE +HAUL_FURNITURE +HAUL_ANIMALS +HANDLE_VEHICLES +HAUL_TRADE +HAUL_WATER +CLEAN +PULL_LEVER +BUILD_ROAD +BUILD_CONSTRUCTION diff --git a/data/stockpiles/adamantinecloth.dfstock b/data/stockpiles/adamantinecloth.dfstock new file mode 100644 index 0000000000..38781d3130 --- /dev/null +++ b/data/stockpiles/adamantinecloth.dfstock @@ -0,0 +1 @@ +rBINORGANIC:ADAMANTINE \ No newline at end of file diff --git a/data/stockpiles/adamantinethread.dfstock b/data/stockpiles/adamantinethread.dfstock new file mode 100644 index 0000000000..2231b389f5 --- /dev/null +++ b/data/stockpiles/adamantinethread.dfstock @@ -0,0 +1 @@ +r"INORGANIC:ADAMANTINE \ No newline at end of file diff --git a/data/stockpiles/adamantineweapons.dfstock b/data/stockpiles/adamantineweapons.dfstock new file mode 100644 index 0000000000..6236196f0e Binary files /dev/null and b/data/stockpiles/adamantineweapons.dfstock differ diff --git a/data/stockpiles/all.dfstock b/data/stockpiles/all.dfstock new file mode 100644 index 0000000000..eace9c53dd Binary files /dev/null and b/data/stockpiles/all.dfstock differ diff --git a/data/stockpiles/artifacts.dfstock b/data/stockpiles/artifacts.dfstock new file mode 100644 index 0000000000..1c7315dfe8 Binary files /dev/null and b/data/stockpiles/artifacts.dfstock differ diff --git a/data/stockpiles/ash.dfstock b/data/stockpiles/ash.dfstock new file mode 100644 index 0000000000..d313e0096d --- /dev/null +++ b/data/stockpiles/ash.dfstock @@ -0,0 +1,2 @@ +R +ASH \ No newline at end of file diff --git a/data/stockpiles/bags.dfstock b/data/stockpiles/bags.dfstock new file mode 100644 index 0000000000..3bfa1a1a17 --- /dev/null +++ b/data/stockpiles/bags.dfstock @@ -0,0 +1,2 @@ + +BAG \ No newline at end of file diff --git a/data/stockpiles/barrels.dfstock b/data/stockpiles/barrels.dfstock new file mode 100644 index 0000000000..70a7239035 --- /dev/null +++ b/data/stockpiles/barrels.dfstock @@ -0,0 +1,2 @@ + +BARREL \ No newline at end of file diff --git a/data/stockpiles/bars.dfstock b/data/stockpiles/bars.dfstock new file mode 100644 index 0000000000..c292dcf562 --- /dev/null +++ b/data/stockpiles/bars.dfstock @@ -0,0 +1,6 @@ +Rõ +COAL +POTASH +ASH +PEARLASH +SOAPINORGANIC:IRONINORGANIC:SILVERINORGANIC:COPPERINORGANIC:NICKELINORGANIC:ZINCINORGANIC:BRONZEINORGANIC:BRASSINORGANIC:STEELINORGANIC:PIG_IRONINORGANIC:PLATINUMINORGANIC:ELECTRUM INORGANIC:TININORGANIC:PEWTER_FINEINORGANIC:PEWTER_TRIFLEINORGANIC:PEWTER_LAYINORGANIC:LEADINORGANIC:ALUMINUMINORGANIC:NICKEL_SILVERINORGANIC:BILLONINORGANIC:STERLING_SILVERINORGANIC:BLACK_BRONZEINORGANIC:ROSE_GOLDINORGANIC:BISMUTHINORGANIC:BISMUTH_BRONZEINORGANIC:ADAMANTINEINORGANIC:GOLDINORGANIC:DIVINE_1INORGANIC:DIVINE_3INORGANIC:DIVINE_5INORGANIC:DIVINE_7INORGANIC:DIVINE_9INORGANIC:DIVINE_11INORGANIC:DIVINE_13INORGANIC:DIVINE_15INORGANIC:DIVINE_17INORGANIC:DIVINE_19 \ No newline at end of file diff --git a/data/stockpiles/bauxite.dfstock b/data/stockpiles/bauxite.dfstock new file mode 100644 index 0000000000..83a49cb5b4 --- /dev/null +++ b/data/stockpiles/bauxite.dfstock @@ -0,0 +1,2 @@ +2 +INORGANIC:BAUXITE \ No newline at end of file diff --git a/data/stockpiles/blocks.dfstock b/data/stockpiles/blocks.dfstock new file mode 100644 index 0000000000..cd08d93338 --- /dev/null +++ b/data/stockpiles/blocks.dfstock @@ -0,0 +1 @@ +Rã GREEN_GLASS CLEAR_GLASS CRYSTAL_GLASSWOOD"INORGANIC:IRON"INORGANIC:SILVER"INORGANIC:COPPER"INORGANIC:NICKEL"INORGANIC:ZINC"INORGANIC:BRONZE"INORGANIC:BRASS"INORGANIC:STEEL"INORGANIC:PIG_IRON"INORGANIC:PLATINUM"INORGANIC:ELECTRUM" INORGANIC:TIN"INORGANIC:PEWTER_FINE"INORGANIC:PEWTER_TRIFLE"INORGANIC:PEWTER_LAY"INORGANIC:LEAD"INORGANIC:ALUMINUM"INORGANIC:NICKEL_SILVER"INORGANIC:BILLON"INORGANIC:STERLING_SILVER"INORGANIC:BLACK_BRONZE"INORGANIC:ROSE_GOLD"INORGANIC:BISMUTH"INORGANIC:BISMUTH_BRONZE"INORGANIC:ADAMANTINE"INORGANIC:PLASTER"INORGANIC:CERAMIC_EARTHENWARE"INORGANIC:CERAMIC_STONEWARE"INORGANIC:CERAMIC_PORCELAIN"INORGANIC:ASH_GLAZE"INORGANIC:TIN_GLAZE"INORGANIC:SANDSTONE"INORGANIC:SILTSTONE"INORGANIC:MUDSTONE"INORGANIC:SHALE"INORGANIC:CLAYSTONE"INORGANIC:ROCK_SALT"INORGANIC:LIMESTONE"INORGANIC:CONGLOMERATE"INORGANIC:DOLOMITE"INORGANIC:CHERT"INORGANIC:CHALK"INORGANIC:GRANITE"INORGANIC:DIORITE"INORGANIC:GABBRO"INORGANIC:RHYOLITE"INORGANIC:BASALT"INORGANIC:ANDESITE"INORGANIC:DACITE"INORGANIC:OBSIDIAN"INORGANIC:QUARTZITE"INORGANIC:SLATE"INORGANIC:PHYLLITE"INORGANIC:SCHIST"INORGANIC:GNEISS"INORGANIC:MARBLE"INORGANIC:HEMATITE"INORGANIC:LIMONITE"INORGANIC:GARNIERITE"INORGANIC:NATIVE_GOLD"INORGANIC:NATIVE_SILVER"INORGANIC:NATIVE_COPPER"INORGANIC:MALACHITE"INORGANIC:GALENA"INORGANIC:SPHALERITE"INORGANIC:CASSITERITE"INORGANIC:COAL_BITUMINOUS"INORGANIC:LIGNITE"INORGANIC:NATIVE_PLATINUM"INORGANIC:CINNABAR"INORGANIC:COBALTITE"INORGANIC:TETRAHEDRITE"INORGANIC:HORN_SILVER"INORGANIC:GYPSUM"INORGANIC:TALC" INORGANIC:JET"INORGANIC:PUDDINGSTONE"INORGANIC:PETRIFIED_WOOD"INORGANIC:GRAPHITE"INORGANIC:BRIMSTONE"INORGANIC:KIMBERLITE"INORGANIC:BISMUTHINITE"INORGANIC:REALGAR"INORGANIC:ORPIMENT"INORGANIC:STIBNITE"INORGANIC:MARCASITE"INORGANIC:SYLVITE"INORGANIC:CRYOLITE"INORGANIC:PERICLASE"INORGANIC:ILMENITE"INORGANIC:RUTILE"INORGANIC:MAGNETITE"INORGANIC:CHROMITE"INORGANIC:PYROLUSITE"INORGANIC:PITCHBLENDE"INORGANIC:BAUXITE"INORGANIC:NATIVE_ALUMINUM"INORGANIC:BORAX"INORGANIC:OLIVINE"INORGANIC:HORNBLENDE"INORGANIC:KAOLINITE"INORGANIC:SERPENTINE"INORGANIC:ORTHOCLASE"INORGANIC:MICROCLINE"INORGANIC:MICA"INORGANIC:CALCITE"INORGANIC:SALTPETER"INORGANIC:ALABASTER"INORGANIC:SELENITE"INORGANIC:SATINSPAR"INORGANIC:ANHYDRITE"INORGANIC:ALUNITE"INORGANIC:RAW_ADAMANTINE"INORGANIC:SLADE" INORGANIC:BROMS_CLEAN_CORPSEDUST"INORGANIC:GOLD"INORGANIC:DIVINE_1"INORGANIC:DIVINE_3"INORGANIC:DIVINE_5"INORGANIC:DIVINE_7"INORGANIC:DIVINE_9"INORGANIC:DIVINE_11"INORGANIC:DIVINE_13"INORGANIC:DIVINE_15"INORGANIC:DIVINE_17"INORGANIC:DIVINE_19 \ No newline at end of file diff --git a/data/stockpiles/bolts.dfstock b/data/stockpiles/bolts.dfstock new file mode 100644 index 0000000000..2e5bd4b4b8 --- /dev/null +++ b/data/stockpiles/bolts.dfstock @@ -0,0 +1,2 @@ +B +AMMO:ITEM_AMMO_BOLTS \ No newline at end of file diff --git a/data/stockpiles/boneammo.dfstock b/data/stockpiles/boneammo.dfstock new file mode 100644 index 0000000000..909c67d1df --- /dev/null +++ b/data/stockpiles/boneammo.dfstock @@ -0,0 +1 @@ +BBONE \ No newline at end of file diff --git a/data/stockpiles/booze.dfstock b/data/stockpiles/booze.dfstock new file mode 100644 index 0000000000..736560f988 Binary files /dev/null and b/data/stockpiles/booze.dfstock differ diff --git a/data/stockpiles/bronzearmor.dfstock b/data/stockpiles/bronzearmor.dfstock new file mode 100644 index 0000000000..22dda4155e Binary files /dev/null and b/data/stockpiles/bronzearmor.dfstock differ diff --git a/data/stockpiles/bronzeweapons.dfstock b/data/stockpiles/bronzeweapons.dfstock new file mode 100644 index 0000000000..54cd87d110 Binary files /dev/null and b/data/stockpiles/bronzeweapons.dfstock differ diff --git a/data/stockpiles/buckets.dfstock b/data/stockpiles/buckets.dfstock new file mode 100644 index 0000000000..cb6b8c4bb5 --- /dev/null +++ b/data/stockpiles/buckets.dfstock @@ -0,0 +1,2 @@ + +BUCKET \ No newline at end of file diff --git a/data/stockpiles/cages.dfstock b/data/stockpiles/cages.dfstock new file mode 100644 index 0000000000..0ca677985c Binary files /dev/null and b/data/stockpiles/cages.dfstock differ diff --git a/data/stockpiles/cat_ammo.dfstock b/data/stockpiles/cat_ammo.dfstock new file mode 100644 index 0000000000..55a20e7e65 --- /dev/null +++ b/data/stockpiles/cat_ammo.dfstock @@ -0,0 +1 @@ +B0 \ No newline at end of file diff --git a/data/stockpiles/cat_animals.dfstock b/data/stockpiles/cat_animals.dfstock new file mode 100644 index 0000000000..9796e4535c --- /dev/null +++ b/data/stockpiles/cat_animals.dfstock @@ -0,0 +1,2 @@ + +  \ No newline at end of file diff --git a/data/stockpiles/cat_armor.dfstock b/data/stockpiles/cat_armor.dfstock new file mode 100644 index 0000000000..54a2d54eee --- /dev/null +++ b/data/stockpiles/cat_armor.dfstock @@ -0,0 +1 @@ +Šh \ No newline at end of file diff --git a/data/stockpiles/cat_bars_blocks.dfstock b/data/stockpiles/cat_bars_blocks.dfstock new file mode 100644 index 0000000000..b7ae54bb1f --- /dev/null +++ b/data/stockpiles/cat_bars_blocks.dfstock @@ -0,0 +1 @@ +R( \ No newline at end of file diff --git a/data/stockpiles/cat_cloth.dfstock b/data/stockpiles/cat_cloth.dfstock new file mode 100644 index 0000000000..d88106c6b8 --- /dev/null +++ b/data/stockpiles/cat_cloth.dfstock @@ -0,0 +1 @@ +rH \ No newline at end of file diff --git a/data/stockpiles/cat_coins.dfstock b/data/stockpiles/cat_coins.dfstock new file mode 100644 index 0000000000..a48133ac40 --- /dev/null +++ b/data/stockpiles/cat_coins.dfstock @@ -0,0 +1 @@ +J \ No newline at end of file diff --git a/data/stockpiles/cat_corpses.dfstock b/data/stockpiles/cat_corpses.dfstock new file mode 100644 index 0000000000..f4edc7ff85 --- /dev/null +++ b/data/stockpiles/cat_corpses.dfstock @@ -0,0 +1 @@ +Ê \ No newline at end of file diff --git a/data/stockpiles/cat_finished_goods.dfstock b/data/stockpiles/cat_finished_goods.dfstock new file mode 100644 index 0000000000..68a2d90531 --- /dev/null +++ b/data/stockpiles/cat_finished_goods.dfstock @@ -0,0 +1 @@ +b0 \ No newline at end of file diff --git a/data/stockpiles/cat_food.dfstock b/data/stockpiles/cat_food.dfstock new file mode 100644 index 0000000000..32829f6776 --- /dev/null +++ b/data/stockpiles/cat_food.dfstock @@ -0,0 +1 @@ +¨ \ No newline at end of file diff --git a/data/stockpiles/cat_furniture.dfstock b/data/stockpiles/cat_furniture.dfstock new file mode 100644 index 0000000000..fdec022edf --- /dev/null +++ b/data/stockpiles/cat_furniture.dfstock @@ -0,0 +1 @@ +8 \ No newline at end of file diff --git a/data/stockpiles/cat_gems.dfstock b/data/stockpiles/cat_gems.dfstock new file mode 100644 index 0000000000..8a6483e26e --- /dev/null +++ b/data/stockpiles/cat_gems.dfstock @@ -0,0 +1 @@ +Z( \ No newline at end of file diff --git a/data/stockpiles/cat_leather.dfstock b/data/stockpiles/cat_leather.dfstock new file mode 100644 index 0000000000..357287897c --- /dev/null +++ b/data/stockpiles/cat_leather.dfstock @@ -0,0 +1 @@ +j \ No newline at end of file diff --git a/data/stockpiles/cat_refuse.dfstock b/data/stockpiles/cat_refuse.dfstock new file mode 100644 index 0000000000..a6219a81af --- /dev/null +++ b/data/stockpiles/cat_refuse.dfstock @@ -0,0 +1 @@ +*` \ No newline at end of file diff --git a/data/stockpiles/cat_sheets.dfstock b/data/stockpiles/cat_sheets.dfstock new file mode 100644 index 0000000000..0230086d80 --- /dev/null +++ b/data/stockpiles/cat_sheets.dfstock @@ -0,0 +1 @@ +Ò \ No newline at end of file diff --git a/data/stockpiles/cat_stone.dfstock b/data/stockpiles/cat_stone.dfstock new file mode 100644 index 0000000000..29bcd227e4 --- /dev/null +++ b/data/stockpiles/cat_stone.dfstock @@ -0,0 +1 @@ +2 \ No newline at end of file diff --git a/data/stockpiles/cat_weapons.dfstock b/data/stockpiles/cat_weapons.dfstock new file mode 100644 index 0000000000..8f46ee6199 --- /dev/null +++ b/data/stockpiles/cat_weapons.dfstock @@ -0,0 +1 @@ +‚H \ No newline at end of file diff --git a/data/stockpiles/cat_wood.dfstock b/data/stockpiles/cat_wood.dfstock new file mode 100644 index 0000000000..5613a0f077 --- /dev/null +++ b/data/stockpiles/cat_wood.dfstock @@ -0,0 +1 @@ +z \ No newline at end of file diff --git a/data/stockpiles/clay.dfstock b/data/stockpiles/clay.dfstock new file mode 100644 index 0000000000..e01c7abaf7 --- /dev/null +++ b/data/stockpiles/clay.dfstock @@ -0,0 +1,6 @@ +2f +INORGANIC:CLAY +INORGANIC:SILTY_CLAY +INORGANIC:SANDY_CLAY +INORGANIC:CLAY_LOAM +INORGANIC:FIRE_CLAY \ No newline at end of file diff --git a/data/stockpiles/cloth.dfstock b/data/stockpiles/cloth.dfstock new file mode 100644 index 0000000000..26c4c52f30 --- /dev/null +++ b/data/stockpiles/cloth.dfstock @@ -0,0 +1 @@ +rŽ'*"CREATURE:SPIDER_BROWN_RECLUSE:SILK*&CREATURE:BROWN_RECLUSE_SPIDER_MAN:SILK*(CREATURE:GIANT_BROWN_RECLUSE_SPIDER:SILK*CREATURE:SPIDER_PHANTOM:SILK*CREATURE:SPIDER_CAVE_GIANT:SILK*CREATURE:SPIDER_CAVE:SILK*INORGANIC:DIVINE_2*INORGANIC:DIVINE_4*INORGANIC:DIVINE_6*INORGANIC:DIVINE_8*INORGANIC:DIVINE_10*INORGANIC:DIVINE_12*INORGANIC:DIVINE_14*INORGANIC:DIVINE_16*INORGANIC:DIVINE_18*INORGANIC:DIVINE_20*CREATURE:FORGOTTEN_BEAST_4:SILK* CREATURE:FORGOTTEN_BEAST_22:SILK* CREATURE:FORGOTTEN_BEAST_33:SILK* CREATURE:FORGOTTEN_BEAST_51:SILK* CREATURE:FORGOTTEN_BEAST_56:SILK* CREATURE:FORGOTTEN_BEAST_58:SILK* CREATURE:FORGOTTEN_BEAST_62:SILK* CREATURE:FORGOTTEN_BEAST_74:SILK* CREATURE:FORGOTTEN_BEAST_80:SILK* CREATURE:FORGOTTEN_BEAST_87:SILK* CREATURE:FORGOTTEN_BEAST_90:SILK*!CREATURE:FORGOTTEN_BEAST_106:SILK*!CREATURE:FORGOTTEN_BEAST_109:SILK*!CREATURE:FORGOTTEN_BEAST_127:SILK*!CREATURE:FORGOTTEN_BEAST_131:SILK*!CREATURE:FORGOTTEN_BEAST_143:SILK*!CREATURE:FORGOTTEN_BEAST_145:SILK*!CREATURE:FORGOTTEN_BEAST_163:SILK*!CREATURE:FORGOTTEN_BEAST_177:SILK*!CREATURE:FORGOTTEN_BEAST_189:SILK*!CREATURE:FORGOTTEN_BEAST_194:SILK*!CREATURE:FORGOTTEN_BEAST_197:SILK*!CREATURE:FORGOTTEN_BEAST_200:SILK*!CREATURE:FORGOTTEN_BEAST_201:SILK*!CREATURE:FORGOTTEN_BEAST_202:SILK*!CREATURE:FORGOTTEN_BEAST_217:SILK*!CREATURE:FORGOTTEN_BEAST_224:SILK*!CREATURE:FORGOTTEN_BEAST_234:SILK*!CREATURE:FORGOTTEN_BEAST_242:SILK*!CREATURE:FORGOTTEN_BEAST_246:SILK*!CREATURE:FORGOTTEN_BEAST_250:SILK*!CREATURE:FORGOTTEN_BEAST_270:SILK*!CREATURE:FORGOTTEN_BEAST_271:SILK*!CREATURE:FORGOTTEN_BEAST_286:SILK*!CREATURE:FORGOTTEN_BEAST_291:SILK*!CREATURE:FORGOTTEN_BEAST_296:SILK*!CREATURE:FORGOTTEN_BEAST_329:SILK*!CREATURE:FORGOTTEN_BEAST_350:SILK*!CREATURE:FORGOTTEN_BEAST_351:SILK*!CREATURE:FORGOTTEN_BEAST_359:SILK*!CREATURE:FORGOTTEN_BEAST_365:SILK*!CREATURE:FORGOTTEN_BEAST_375:SILK*!CREATURE:FORGOTTEN_BEAST_376:SILK*!CREATURE:FORGOTTEN_BEAST_377:SILK*!CREATURE:FORGOTTEN_BEAST_383:SILK*!CREATURE:FORGOTTEN_BEAST_387:SILK*!CREATURE:FORGOTTEN_BEAST_398:SILK*!CREATURE:FORGOTTEN_BEAST_400:SILK*!CREATURE:FORGOTTEN_BEAST_406:SILK*!CREATURE:FORGOTTEN_BEAST_410:SILK*!CREATURE:FORGOTTEN_BEAST_417:SILK*!CREATURE:FORGOTTEN_BEAST_428:SILK*!CREATURE:FORGOTTEN_BEAST_429:SILK*!CREATURE:FORGOTTEN_BEAST_432:SILK*!CREATURE:FORGOTTEN_BEAST_442:SILK*!CREATURE:FORGOTTEN_BEAST_448:SILK*!CREATURE:FORGOTTEN_BEAST_452:SILK*!CREATURE:FORGOTTEN_BEAST_457:SILK*!CREATURE:FORGOTTEN_BEAST_468:SILK*!CREATURE:FORGOTTEN_BEAST_472:SILK*!CREATURE:FORGOTTEN_BEAST_479:SILK*!CREATURE:FORGOTTEN_BEAST_482:SILK*!CREATURE:FORGOTTEN_BEAST_492:SILK*!CREATURE:FORGOTTEN_BEAST_504:SILK*!CREATURE:FORGOTTEN_BEAST_512:SILK*!CREATURE:FORGOTTEN_BEAST_519:SILK*!CREATURE:FORGOTTEN_BEAST_537:SILK*!CREATURE:FORGOTTEN_BEAST_550:SILK*!CREATURE:FORGOTTEN_BEAST_556:SILK*!CREATURE:FORGOTTEN_BEAST_557:SILK*!CREATURE:FORGOTTEN_BEAST_563:SILK*!CREATURE:FORGOTTEN_BEAST_573:SILK*!CREATURE:FORGOTTEN_BEAST_583:SILK*!CREATURE:FORGOTTEN_BEAST_588:SILK*!CREATURE:FORGOTTEN_BEAST_599:SILK*!CREATURE:FORGOTTEN_BEAST_602:SILK*!CREATURE:FORGOTTEN_BEAST_605:SILK*!CREATURE:FORGOTTEN_BEAST_607:SILK*!CREATURE:FORGOTTEN_BEAST_611:SILK*!CREATURE:FORGOTTEN_BEAST_618:SILK*!CREATURE:FORGOTTEN_BEAST_621:SILK*!CREATURE:FORGOTTEN_BEAST_627:SILK*!CREATURE:FORGOTTEN_BEAST_638:SILK*!CREATURE:FORGOTTEN_BEAST_639:SILK*!CREATURE:FORGOTTEN_BEAST_651:SILK*!CREATURE:FORGOTTEN_BEAST_659:SILK*!CREATURE:FORGOTTEN_BEAST_670:SILK*!CREATURE:FORGOTTEN_BEAST_686:SILK*!CREATURE:FORGOTTEN_BEAST_692:SILK*!CREATURE:FORGOTTEN_BEAST_695:SILK*!CREATURE:FORGOTTEN_BEAST_697:SILK*!CREATURE:FORGOTTEN_BEAST_699:SILK*!CREATURE:FORGOTTEN_BEAST_707:SILK*!CREATURE:FORGOTTEN_BEAST_713:SILK*!CREATURE:FORGOTTEN_BEAST_723:SILK*!CREATURE:FORGOTTEN_BEAST_733:SILK*!CREATURE:FORGOTTEN_BEAST_740:SILK*!CREATURE:FORGOTTEN_BEAST_741:SILK*!CREATURE:FORGOTTEN_BEAST_747:SILK*!CREATURE:FORGOTTEN_BEAST_758:SILK*!CREATURE:FORGOTTEN_BEAST_766:SILK*!CREATURE:FORGOTTEN_BEAST_769:SILK*!CREATURE:FORGOTTEN_BEAST_771:SILK*!CREATURE:FORGOTTEN_BEAST_790:SILK*!CREATURE:FORGOTTEN_BEAST_794:SILK*!CREATURE:FORGOTTEN_BEAST_826:SILK*!CREATURE:FORGOTTEN_BEAST_827:SILK*!CREATURE:FORGOTTEN_BEAST_837:SILK*!CREATURE:FORGOTTEN_BEAST_839:SILK*!CREATURE:FORGOTTEN_BEAST_846:SILK*!CREATURE:FORGOTTEN_BEAST_847:SILK*!CREATURE:FORGOTTEN_BEAST_849:SILK*!CREATURE:FORGOTTEN_BEAST_850:SILK*!CREATURE:FORGOTTEN_BEAST_855:SILK*CREATURE:TITAN_1:SILK*CREATURE:TITAN_5:SILK*CREATURE:TITAN_18:SILK*CREATURE:TITAN_24:SILK*CREATURE:TITAN_28:SILK*CREATURE:TITAN_29:SILK*CREATURE:TITAN_30:SILK*CREATURE:TITAN_31:SILK*CREATURE:DEMON_13:SILK*CREATURE:DEMON_15:SILK*CREATURE:DEMON_43:SILK*CREATURE:DEMON_46:SILK*CREATURE:DEMON_49:SILK*CREATURE:DEMON_50:SILK*CREATURE:DEMON_52:SILK2PLANT:FLAX:THREAD2PLANT:JUTE:THREAD2PLANT:HEMP:THREAD2PLANT:COTTON:THREAD2PLANT:RAMIE:THREAD2PLANT:KENAF:THREAD2PLANT:GRASS_TAIL_PIG:THREAD2PLANT:REED_ROPE:THREAD:CREATURE:SHEEP:HAIR:CREATURE:LLAMA:HAIR:CREATURE:ALPACA:HAIR:CREATURE:TROLL:HAIR \ No newline at end of file diff --git a/data/stockpiles/coal.dfstock b/data/stockpiles/coal.dfstock new file mode 100644 index 0000000000..8e9ec16e04 --- /dev/null +++ b/data/stockpiles/coal.dfstock @@ -0,0 +1,2 @@ +R +COAL \ No newline at end of file diff --git a/data/stockpiles/coalproducing.dfstock b/data/stockpiles/coalproducing.dfstock new file mode 100644 index 0000000000..30d6f7adf1 --- /dev/null +++ b/data/stockpiles/coalproducing.dfstock @@ -0,0 +1,3 @@ +2. +INORGANIC:COAL_BITUMINOUS +INORGANIC:LIGNITE \ No newline at end of file diff --git a/data/stockpiles/copperarmor.dfstock b/data/stockpiles/copperarmor.dfstock new file mode 100644 index 0000000000..bc7b8ec58e Binary files /dev/null and b/data/stockpiles/copperarmor.dfstock differ diff --git a/data/stockpiles/copperweapons.dfstock b/data/stockpiles/copperweapons.dfstock new file mode 100644 index 0000000000..a30c53107a Binary files /dev/null and b/data/stockpiles/copperweapons.dfstock differ diff --git a/data/stockpiles/crafts.dfstock b/data/stockpiles/crafts.dfstock new file mode 100644 index 0000000000..633dd9f1f2 --- /dev/null +++ b/data/stockpiles/crafts.dfstock @@ -0,0 +1,10 @@ +bG +FIGURINE +AMULET +SCEPTER +CROWN +RING +EARRING +BRACELET +GEM +TOTEM \ No newline at end of file diff --git a/data/stockpiles/cutgems.dfstock b/data/stockpiles/cutgems.dfstock new file mode 100644 index 0000000000..1049acd673 --- /dev/null +++ b/data/stockpiles/cutgems.dfstock @@ -0,0 +1 @@ +ZÃ"INORGANIC:ONYX"INORGANIC:MORION"INORGANIC:SCHORL"INORGANIC:LACE AGATE"INORGANIC:BLUE JADE"INORGANIC:LAPIS LAZULI"INORGANIC:PRASE"INORGANIC:PRASE OPAL"INORGANIC:BLOODSTONE"INORGANIC:MOSS AGATE"INORGANIC:MOSS OPAL"INORGANIC:VARISCITE"INORGANIC:CHRYSOPRASE"INORGANIC:CHRYSOCOLLA"INORGANIC:SARD"INORGANIC:CARNELIAN"INORGANIC:BANDED AGATE"INORGANIC:SARDONYX"INORGANIC:CHERRY OPAL"INORGANIC:LAVENDER JADE"INORGANIC:PINK JADE"INORGANIC:TUBE AGATE"INORGANIC:FIRE AGATE"INORGANIC:PLUME AGATE"INORGANIC:BROWN JASPER"INORGANIC:PICTURE JASPER"INORGANIC:SMOKY QUARTZ"INORGANIC:WAX OPAL"INORGANIC:WOOD OPAL"INORGANIC:AMBER OPAL"INORGANIC:GOLD OPAL"INORGANIC:CITRINE"INORGANIC:YELLOW JASPER"INORGANIC:TIGEREYE"INORGANIC:TIGER IRON"INORGANIC:SUNSTONE"INORGANIC:RESIN OPAL"INORGANIC:PYRITE"INORGANIC:CLEAR TOURMALINE"INORGANIC:GRAY CHALCEDONY"INORGANIC:DENDRITIC AGATE"INORGANIC:SHELL OPAL"INORGANIC:BONE OPAL"INORGANIC:WHITE CHALCEDONY"INORGANIC:FORTIFICATION AGATE"INORGANIC:MILK QUARTZ"INORGANIC:MOONSTONE"INORGANIC:WHITE JADE"INORGANIC:JASPER OPAL"INORGANIC:PINEAPPLE OPAL"INORGANIC:ONYX OPAL"INORGANIC:MILK OPAL"INORGANIC:PIPE OPAL"INORGANIC:AVENTURINE"INORGANIC:TURQUOISE"INORGANIC:QUARTZ_ROSE"INORGANIC:CRYSTAL_ROCK"INORGANIC:BLACK ZIRCON"INORGANIC:BLACK PYROPE"INORGANIC:MELANITE"INORGANIC:INDIGO TOURMALINE"INORGANIC:BLUE GARNET"INORGANIC:TSAVORITE"INORGANIC:GREEN TOURMALINE"INORGANIC:DEMANTOID"INORGANIC:GREEN ZIRCON"INORGANIC:GREEN JADE"INORGANIC:HELIODOR"INORGANIC:PERIDOT"INORGANIC:RED ZIRCON"INORGANIC:RED TOURMALINE"INORGANIC:RED PYROPE"INORGANIC:ALMANDINE"INORGANIC:RED GROSSULAR"INORGANIC:PINK TOURMALINE"INORGANIC:RED BERYL"INORGANIC:FIRE OPAL"INORGANIC:RHODOLITE"INORGANIC:SPINEL_PURPLE"INORGANIC:ALEXANDRITE"INORGANIC:TANZANITE"INORGANIC:MORGANITE"INORGANIC:VIOLET SPESSARTINE"INORGANIC:PINK GARNET"INORGANIC:KUNZITE"INORGANIC:CINNAMON GROSSULAR"INORGANIC:HONEY YELLOW BERYL"INORGANIC:JELLY OPAL"INORGANIC:BROWN ZIRCON"INORGANIC:YELLOW ZIRCON"INORGANIC:GOLDEN BERYL"INORGANIC:YELLOW SPESSARTINE"INORGANIC:TOPAZ"INORGANIC:TOPAZOLITE"INORGANIC:YELLOW GROSSULAR"INORGANIC:RUBICELLE"INORGANIC:CLEAR GARNET"INORGANIC:GOSHENITE"INORGANIC:CAT'S EYE"INORGANIC:CLEAR ZIRCON"INORGANIC:AMETHYST"INORGANIC:AQUAMARINE"INORGANIC:SPINEL_RED"INORGANIC:CHRYSOBERYL"INORGANIC:OPAL_PFIRE"INORGANIC:OPAL_REDFLASH"INORGANIC:OPAL_BLACK"INORGANIC:OPAL_WHITE"INORGANIC:OPAL_CRYSTAL"INORGANIC:OPAL_CLARO"INORGANIC:OPAL_LEVIN"INORGANIC:OPAL_HARLEQUIN"INORGANIC:OPAL_PINFIRE"INORGANIC:OPAL_BANDFIRE"INORGANIC:DIAMOND_LY"INORGANIC:DIAMOND_FY"INORGANIC:EMERALD"INORGANIC:RUBY"INORGANIC:SAPPHIRE"INORGANIC:DIAMOND_CLEAR"INORGANIC:DIAMOND_RED"INORGANIC:DIAMOND_GREEN"INORGANIC:DIAMOND_BLUE"INORGANIC:DIAMOND_YELLOW"INORGANIC:DIAMOND_BLACK"INORGANIC:SAPPHIRE_STAR"INORGANIC:RUBY_STAR \ No newline at end of file diff --git a/data/stockpiles/cutglass.dfstock b/data/stockpiles/cutglass.dfstock new file mode 100644 index 0000000000..6997d42acd --- /dev/null +++ b/data/stockpiles/cutglass.dfstock @@ -0,0 +1 @@ +Z) GLASS_GREEN GLASS_CLEAR GLASS_CRYSTAL \ No newline at end of file diff --git a/data/stockpiles/cutstone.dfstock b/data/stockpiles/cutstone.dfstock new file mode 100644 index 0000000000..5e0f3f881b --- /dev/null +++ b/data/stockpiles/cutstone.dfstock @@ -0,0 +1 @@ +Zâ"INORGANIC:PLASTER"INORGANIC:CERAMIC_EARTHENWARE"INORGANIC:CERAMIC_STONEWARE"INORGANIC:CERAMIC_PORCELAIN"INORGANIC:ASH_GLAZE"INORGANIC:TIN_GLAZE"INORGANIC:SANDSTONE"INORGANIC:SILTSTONE"INORGANIC:MUDSTONE"INORGANIC:SHALE"INORGANIC:CLAYSTONE"INORGANIC:ROCK_SALT"INORGANIC:LIMESTONE"INORGANIC:CONGLOMERATE"INORGANIC:DOLOMITE"INORGANIC:CHERT"INORGANIC:CHALK"INORGANIC:GRANITE"INORGANIC:DIORITE"INORGANIC:GABBRO"INORGANIC:RHYOLITE"INORGANIC:BASALT"INORGANIC:ANDESITE"INORGANIC:DACITE"INORGANIC:OBSIDIAN"INORGANIC:QUARTZITE"INORGANIC:SLATE"INORGANIC:PHYLLITE"INORGANIC:SCHIST"INORGANIC:GNEISS"INORGANIC:MARBLE"INORGANIC:HEMATITE"INORGANIC:LIMONITE"INORGANIC:GARNIERITE"INORGANIC:NATIVE_GOLD"INORGANIC:NATIVE_SILVER"INORGANIC:NATIVE_COPPER"INORGANIC:MALACHITE"INORGANIC:GALENA"INORGANIC:SPHALERITE"INORGANIC:CASSITERITE"INORGANIC:COAL_BITUMINOUS"INORGANIC:LIGNITE"INORGANIC:NATIVE_PLATINUM"INORGANIC:CINNABAR"INORGANIC:COBALTITE"INORGANIC:TETRAHEDRITE"INORGANIC:HORN_SILVER"INORGANIC:GYPSUM"INORGANIC:TALC" INORGANIC:JET"INORGANIC:PUDDINGSTONE"INORGANIC:PETRIFIED_WOOD"INORGANIC:GRAPHITE"INORGANIC:BRIMSTONE"INORGANIC:KIMBERLITE"INORGANIC:BISMUTHINITE"INORGANIC:REALGAR"INORGANIC:ORPIMENT"INORGANIC:STIBNITE"INORGANIC:MARCASITE"INORGANIC:SYLVITE"INORGANIC:CRYOLITE"INORGANIC:PERICLASE"INORGANIC:ILMENITE"INORGANIC:RUTILE"INORGANIC:MAGNETITE"INORGANIC:CHROMITE"INORGANIC:PYROLUSITE"INORGANIC:PITCHBLENDE"INORGANIC:BAUXITE"INORGANIC:NATIVE_ALUMINUM"INORGANIC:BORAX"INORGANIC:OLIVINE"INORGANIC:HORNBLENDE"INORGANIC:KAOLINITE"INORGANIC:SERPENTINE"INORGANIC:ORTHOCLASE"INORGANIC:MICROCLINE"INORGANIC:MICA"INORGANIC:CALCITE"INORGANIC:SALTPETER"INORGANIC:ALABASTER"INORGANIC:SELENITE"INORGANIC:SATINSPAR"INORGANIC:ANHYDRITE"INORGANIC:ALUNITE"INORGANIC:RAW_ADAMANTINE"INORGANIC:SLADE" INORGANIC:BROMS_CLEAN_CORPSEDUST \ No newline at end of file diff --git a/data/stockpiles/dye.dfstock b/data/stockpiles/dye.dfstock new file mode 100644 index 0000000000..67b785d203 Binary files /dev/null and b/data/stockpiles/dye.dfstock differ diff --git a/data/stockpiles/economic.dfstock b/data/stockpiles/economic.dfstock new file mode 100644 index 0000000000..976f4cc11f --- /dev/null +++ b/data/stockpiles/economic.dfstock @@ -0,0 +1,13 @@ +2ò +INORGANIC:LIMESTONE +INORGANIC:DOLOMITE +INORGANIC:CHALK +INORGANIC:MARBLE +INORGANIC:COAL_BITUMINOUS +INORGANIC:LIGNITE +INORGANIC:GYPSUM +INORGANIC:KAOLINITE +INORGANIC:CALCITE +INORGANIC:ALABASTER +INORGANIC:SELENITE +INORGANIC:SATINSPAR \ No newline at end of file diff --git a/data/stockpiles/everything.dfstock b/data/stockpiles/everything.dfstock new file mode 100644 index 0000000000..c0fcb60519 Binary files /dev/null and b/data/stockpiles/everything.dfstock differ diff --git a/data/stockpiles/flux.dfstock b/data/stockpiles/flux.dfstock new file mode 100644 index 0000000000..ec86187db1 --- /dev/null +++ b/data/stockpiles/flux.dfstock @@ -0,0 +1,6 @@ +2_ +INORGANIC:LIMESTONE +INORGANIC:DOLOMITE +INORGANIC:CHALK +INORGANIC:MARBLE +INORGANIC:CALCITE \ No newline at end of file diff --git a/data/stockpiles/goblets.dfstock b/data/stockpiles/goblets.dfstock new file mode 100644 index 0000000000..bff4f8a6d3 --- /dev/null +++ b/data/stockpiles/goblets.dfstock @@ -0,0 +1,2 @@ +b +GOBLET \ No newline at end of file diff --git a/data/stockpiles/ironarmor.dfstock b/data/stockpiles/ironarmor.dfstock new file mode 100644 index 0000000000..9474bd69f3 Binary files /dev/null and b/data/stockpiles/ironarmor.dfstock differ diff --git a/data/stockpiles/ironbars.dfstock b/data/stockpiles/ironbars.dfstock new file mode 100644 index 0000000000..2cb77c0e35 --- /dev/null +++ b/data/stockpiles/ironbars.dfstock @@ -0,0 +1 @@ +RINORGANIC:IRON \ No newline at end of file diff --git a/data/stockpiles/ironore.dfstock b/data/stockpiles/ironore.dfstock new file mode 100644 index 0000000000..2108b60ac3 --- /dev/null +++ b/data/stockpiles/ironore.dfstock @@ -0,0 +1,4 @@ +2= +INORGANIC:HEMATITE +INORGANIC:LIMONITE +INORGANIC:MAGNETITE \ No newline at end of file diff --git a/data/stockpiles/ironweapons.dfstock b/data/stockpiles/ironweapons.dfstock new file mode 100644 index 0000000000..8c0afecd16 Binary files /dev/null and b/data/stockpiles/ironweapons.dfstock differ diff --git a/data/stockpiles/masterworks.dfstock b/data/stockpiles/masterworks.dfstock new file mode 100644 index 0000000000..fa94c86a93 Binary files /dev/null and b/data/stockpiles/masterworks.dfstock differ diff --git a/data/stockpiles/metalammo.dfstock b/data/stockpiles/metalammo.dfstock new file mode 100644 index 0000000000..f1d9cdee9c --- /dev/null +++ b/data/stockpiles/metalammo.dfstock @@ -0,0 +1 @@ +BÒINORGANIC:IRONINORGANIC:SILVERINORGANIC:COPPERINORGANIC:NICKELINORGANIC:ZINCINORGANIC:BRONZEINORGANIC:BRASSINORGANIC:STEELINORGANIC:PIG_IRONINORGANIC:PLATINUMINORGANIC:ELECTRUM INORGANIC:TININORGANIC:PEWTER_FINEINORGANIC:PEWTER_TRIFLEINORGANIC:PEWTER_LAYINORGANIC:LEADINORGANIC:ALUMINUMINORGANIC:NICKEL_SILVERINORGANIC:BILLONINORGANIC:STERLING_SILVERINORGANIC:BLACK_BRONZEINORGANIC:ROSE_GOLDINORGANIC:BISMUTHINORGANIC:BISMUTH_BRONZEINORGANIC:ADAMANTINEINORGANIC:GOLDINORGANIC:DIVINE_1INORGANIC:DIVINE_3INORGANIC:DIVINE_5INORGANIC:DIVINE_7INORGANIC:DIVINE_9INORGANIC:DIVINE_11INORGANIC:DIVINE_13INORGANIC:DIVINE_15INORGANIC:DIVINE_17INORGANIC:DIVINE_19 \ No newline at end of file diff --git a/data/stockpiles/metalarmor.dfstock b/data/stockpiles/metalarmor.dfstock new file mode 100644 index 0000000000..f3a00646aa Binary files /dev/null and b/data/stockpiles/metalarmor.dfstock differ diff --git a/data/stockpiles/metalbars.dfstock b/data/stockpiles/metalbars.dfstock new file mode 100644 index 0000000000..103619c508 --- /dev/null +++ b/data/stockpiles/metalbars.dfstock @@ -0,0 +1 @@ +RÒINORGANIC:IRONINORGANIC:SILVERINORGANIC:COPPERINORGANIC:NICKELINORGANIC:ZINCINORGANIC:BRONZEINORGANIC:BRASSINORGANIC:STEELINORGANIC:PIG_IRONINORGANIC:PLATINUMINORGANIC:ELECTRUM INORGANIC:TININORGANIC:PEWTER_FINEINORGANIC:PEWTER_TRIFLEINORGANIC:PEWTER_LAYINORGANIC:LEADINORGANIC:ALUMINUMINORGANIC:NICKEL_SILVERINORGANIC:BILLONINORGANIC:STERLING_SILVERINORGANIC:BLACK_BRONZEINORGANIC:ROSE_GOLDINORGANIC:BISMUTHINORGANIC:BISMUTH_BRONZEINORGANIC:ADAMANTINEINORGANIC:GOLDINORGANIC:DIVINE_1INORGANIC:DIVINE_3INORGANIC:DIVINE_5INORGANIC:DIVINE_7INORGANIC:DIVINE_9INORGANIC:DIVINE_11INORGANIC:DIVINE_13INORGANIC:DIVINE_15INORGANIC:DIVINE_17INORGANIC:DIVINE_19 \ No newline at end of file diff --git a/data/stockpiles/metalore.dfstock b/data/stockpiles/metalore.dfstock new file mode 100644 index 0000000000..8cbb60959e --- /dev/null +++ b/data/stockpiles/metalore.dfstock @@ -0,0 +1,17 @@ +2í +INORGANIC:HEMATITE +INORGANIC:LIMONITE +INORGANIC:GARNIERITE +INORGANIC:NATIVE_GOLD +INORGANIC:NATIVE_SILVER +INORGANIC:NATIVE_COPPER +INORGANIC:MALACHITE +INORGANIC:GALENA +INORGANIC:SPHALERITE +INORGANIC:CASSITERITE +INORGANIC:NATIVE_PLATINUM +INORGANIC:TETRAHEDRITE +INORGANIC:HORN_SILVER +INORGANIC:BISMUTHINITE +INORGANIC:MAGNETITE +INORGANIC:NATIVE_ALUMINUM \ No newline at end of file diff --git a/data/stockpiles/metalweapons.dfstock b/data/stockpiles/metalweapons.dfstock new file mode 100644 index 0000000000..b9cd665117 Binary files /dev/null and b/data/stockpiles/metalweapons.dfstock differ diff --git a/data/stockpiles/miscliquid.dfstock b/data/stockpiles/miscliquid.dfstock new file mode 100644 index 0000000000..dbf75a072e Binary files /dev/null and b/data/stockpiles/miscliquid.dfstock differ diff --git a/data/stockpiles/organic.dfstock b/data/stockpiles/organic.dfstock new file mode 100644 index 0000000000..70f0496ca3 Binary files /dev/null and b/data/stockpiles/organic.dfstock differ diff --git a/data/stockpiles/otherarmor.dfstock b/data/stockpiles/otherarmor.dfstock new file mode 100644 index 0000000000..ec857e0cc3 Binary files /dev/null and b/data/stockpiles/otherarmor.dfstock differ diff --git a/data/stockpiles/otherbars.dfstock b/data/stockpiles/otherbars.dfstock new file mode 100644 index 0000000000..4cbcc1c8f9 --- /dev/null +++ b/data/stockpiles/otherbars.dfstock @@ -0,0 +1,6 @@ +R# +COAL +POTASH +ASH +PEARLASH +SOAP \ No newline at end of file diff --git a/data/stockpiles/otherstone.dfstock b/data/stockpiles/otherstone.dfstock new file mode 100644 index 0000000000..1f9f867edf --- /dev/null +++ b/data/stockpiles/otherstone.dfstock @@ -0,0 +1,56 @@ +2Ë +INORGANIC:SANDSTONE +INORGANIC:SILTSTONE +INORGANIC:MUDSTONE +INORGANIC:SHALE +INORGANIC:CLAYSTONE +INORGANIC:ROCK_SALT +INORGANIC:CONGLOMERATE +INORGANIC:CHERT +INORGANIC:GRANITE +INORGANIC:DIORITE +INORGANIC:GABBRO +INORGANIC:RHYOLITE +INORGANIC:BASALT +INORGANIC:ANDESITE +INORGANIC:DACITE +INORGANIC:OBSIDIAN +INORGANIC:QUARTZITE +INORGANIC:SLATE +INORGANIC:PHYLLITE +INORGANIC:SCHIST +INORGANIC:GNEISS +INORGANIC:CINNABAR +INORGANIC:COBALTITE +INORGANIC:TALC + INORGANIC:JET +INORGANIC:PUDDINGSTONE +INORGANIC:PETRIFIED_WOOD +INORGANIC:GRAPHITE +INORGANIC:BRIMSTONE +INORGANIC:KIMBERLITE +INORGANIC:REALGAR +INORGANIC:ORPIMENT +INORGANIC:STIBNITE +INORGANIC:MARCASITE +INORGANIC:SYLVITE +INORGANIC:CRYOLITE +INORGANIC:PERICLASE +INORGANIC:ILMENITE +INORGANIC:RUTILE +INORGANIC:CHROMITE +INORGANIC:PYROLUSITE +INORGANIC:PITCHBLENDE +INORGANIC:BAUXITE +INORGANIC:BORAX +INORGANIC:OLIVINE +INORGANIC:HORNBLENDE +INORGANIC:SERPENTINE +INORGANIC:ORTHOCLASE +INORGANIC:MICROCLINE +INORGANIC:MICA +INORGANIC:SALTPETER +INORGANIC:ANHYDRITE +INORGANIC:ALUNITE +INORGANIC:RAW_ADAMANTINE +INORGANIC:SLADE \ No newline at end of file diff --git a/data/stockpiles/otherweapons.dfstock b/data/stockpiles/otherweapons.dfstock new file mode 100644 index 0000000000..f1127a7841 Binary files /dev/null and b/data/stockpiles/otherweapons.dfstock differ diff --git a/data/stockpiles/pearlash.dfstock b/data/stockpiles/pearlash.dfstock new file mode 100644 index 0000000000..3cea5164da --- /dev/null +++ b/data/stockpiles/pearlash.dfstock @@ -0,0 +1,3 @@ +R + +PEARLASH \ No newline at end of file diff --git a/data/stockpiles/pigironbars.dfstock b/data/stockpiles/pigironbars.dfstock new file mode 100644 index 0000000000..f07b1def24 --- /dev/null +++ b/data/stockpiles/pigironbars.dfstock @@ -0,0 +1 @@ +RINORGANIC:PIG_IRON \ No newline at end of file diff --git a/data/stockpiles/plants.dfstock b/data/stockpiles/plants.dfstock new file mode 100644 index 0000000000..ca55f19f98 Binary files /dev/null and b/data/stockpiles/plants.dfstock differ diff --git a/data/stockpiles/plasterproducing.dfstock b/data/stockpiles/plasterproducing.dfstock new file mode 100644 index 0000000000..2764150a3f --- /dev/null +++ b/data/stockpiles/plasterproducing.dfstock @@ -0,0 +1,5 @@ +2P +INORGANIC:GYPSUM +INORGANIC:ALABASTER +INORGANIC:SELENITE +INORGANIC:SATINSPAR \ No newline at end of file diff --git a/data/stockpiles/platinumweapons.dfstock b/data/stockpiles/platinumweapons.dfstock new file mode 100644 index 0000000000..162865512b Binary files /dev/null and b/data/stockpiles/platinumweapons.dfstock differ diff --git a/data/stockpiles/potash.dfstock b/data/stockpiles/potash.dfstock new file mode 100644 index 0000000000..8a09e446fe --- /dev/null +++ b/data/stockpiles/potash.dfstock @@ -0,0 +1,2 @@ +R +POTASH \ No newline at end of file diff --git a/data/stockpiles/pots.dfstock b/data/stockpiles/pots.dfstock new file mode 100644 index 0000000000..2c1fe0e5ca --- /dev/null +++ b/data/stockpiles/pots.dfstock @@ -0,0 +1,2 @@ + + FOOD_STORAGE \ No newline at end of file diff --git a/data/stockpiles/preparedmeals.dfstock b/data/stockpiles/preparedmeals.dfstock new file mode 100644 index 0000000000..657c93f389 --- /dev/null +++ b/data/stockpiles/preparedmeals.dfstock @@ -0,0 +1 @@ +˜ \ No newline at end of file diff --git a/data/stockpiles/rawhides.dfstock b/data/stockpiles/rawhides.dfstock new file mode 100644 index 0000000000..eedc71760d Binary files /dev/null and b/data/stockpiles/rawhides.dfstock differ diff --git a/data/stockpiles/roughgems.dfstock b/data/stockpiles/roughgems.dfstock new file mode 100644 index 0000000000..fdad4be1ad --- /dev/null +++ b/data/stockpiles/roughgems.dfstock @@ -0,0 +1 @@ +ZÃINORGANIC:ONYXINORGANIC:MORIONINORGANIC:SCHORLINORGANIC:LACE AGATEINORGANIC:BLUE JADEINORGANIC:LAPIS LAZULIINORGANIC:PRASEINORGANIC:PRASE OPALINORGANIC:BLOODSTONEINORGANIC:MOSS AGATEINORGANIC:MOSS OPALINORGANIC:VARISCITEINORGANIC:CHRYSOPRASEINORGANIC:CHRYSOCOLLAINORGANIC:SARDINORGANIC:CARNELIANINORGANIC:BANDED AGATEINORGANIC:SARDONYXINORGANIC:CHERRY OPALINORGANIC:LAVENDER JADEINORGANIC:PINK JADEINORGANIC:TUBE AGATEINORGANIC:FIRE AGATEINORGANIC:PLUME AGATEINORGANIC:BROWN JASPERINORGANIC:PICTURE JASPERINORGANIC:SMOKY QUARTZINORGANIC:WAX OPALINORGANIC:WOOD OPALINORGANIC:AMBER OPALINORGANIC:GOLD OPALINORGANIC:CITRINEINORGANIC:YELLOW JASPERINORGANIC:TIGEREYEINORGANIC:TIGER IRONINORGANIC:SUNSTONEINORGANIC:RESIN OPALINORGANIC:PYRITEINORGANIC:CLEAR TOURMALINEINORGANIC:GRAY CHALCEDONYINORGANIC:DENDRITIC AGATEINORGANIC:SHELL OPALINORGANIC:BONE OPALINORGANIC:WHITE CHALCEDONYINORGANIC:FORTIFICATION AGATEINORGANIC:MILK QUARTZINORGANIC:MOONSTONEINORGANIC:WHITE JADEINORGANIC:JASPER OPALINORGANIC:PINEAPPLE OPALINORGANIC:ONYX OPALINORGANIC:MILK OPALINORGANIC:PIPE OPALINORGANIC:AVENTURINEINORGANIC:TURQUOISEINORGANIC:QUARTZ_ROSEINORGANIC:CRYSTAL_ROCKINORGANIC:BLACK ZIRCONINORGANIC:BLACK PYROPEINORGANIC:MELANITEINORGANIC:INDIGO TOURMALINEINORGANIC:BLUE GARNETINORGANIC:TSAVORITEINORGANIC:GREEN TOURMALINEINORGANIC:DEMANTOIDINORGANIC:GREEN ZIRCONINORGANIC:GREEN JADEINORGANIC:HELIODORINORGANIC:PERIDOTINORGANIC:RED ZIRCONINORGANIC:RED TOURMALINEINORGANIC:RED PYROPEINORGANIC:ALMANDINEINORGANIC:RED GROSSULARINORGANIC:PINK TOURMALINEINORGANIC:RED BERYLINORGANIC:FIRE OPALINORGANIC:RHODOLITEINORGANIC:SPINEL_PURPLEINORGANIC:ALEXANDRITEINORGANIC:TANZANITEINORGANIC:MORGANITEINORGANIC:VIOLET SPESSARTINEINORGANIC:PINK GARNETINORGANIC:KUNZITEINORGANIC:CINNAMON GROSSULARINORGANIC:HONEY YELLOW BERYLINORGANIC:JELLY OPALINORGANIC:BROWN ZIRCONINORGANIC:YELLOW ZIRCONINORGANIC:GOLDEN BERYLINORGANIC:YELLOW SPESSARTINEINORGANIC:TOPAZINORGANIC:TOPAZOLITEINORGANIC:YELLOW GROSSULARINORGANIC:RUBICELLEINORGANIC:CLEAR GARNETINORGANIC:GOSHENITEINORGANIC:CAT'S EYEINORGANIC:CLEAR ZIRCONINORGANIC:AMETHYSTINORGANIC:AQUAMARINEINORGANIC:SPINEL_REDINORGANIC:CHRYSOBERYLINORGANIC:OPAL_PFIREINORGANIC:OPAL_REDFLASHINORGANIC:OPAL_BLACKINORGANIC:OPAL_WHITEINORGANIC:OPAL_CRYSTALINORGANIC:OPAL_CLAROINORGANIC:OPAL_LEVININORGANIC:OPAL_HARLEQUININORGANIC:OPAL_PINFIREINORGANIC:OPAL_BANDFIREINORGANIC:DIAMOND_LYINORGANIC:DIAMOND_FYINORGANIC:EMERALDINORGANIC:RUBYINORGANIC:SAPPHIREINORGANIC:DIAMOND_CLEARINORGANIC:DIAMOND_REDINORGANIC:DIAMOND_GREENINORGANIC:DIAMOND_BLUEINORGANIC:DIAMOND_YELLOWINORGANIC:DIAMOND_BLACKINORGANIC:SAPPHIRE_STARINORGANIC:RUBY_STAR \ No newline at end of file diff --git a/data/stockpiles/roughglass.dfstock b/data/stockpiles/roughglass.dfstock new file mode 100644 index 0000000000..23b95b81ac --- /dev/null +++ b/data/stockpiles/roughglass.dfstock @@ -0,0 +1,4 @@ +Z) + GLASS_GREEN + GLASS_CLEAR + GLASS_CRYSTAL \ No newline at end of file diff --git a/data/stockpiles/sand.dfstock b/data/stockpiles/sand.dfstock new file mode 100644 index 0000000000..b97921e81e --- /dev/null +++ b/data/stockpiles/sand.dfstock @@ -0,0 +1,3 @@ + + +SAND_BAG \ No newline at end of file diff --git a/data/stockpiles/seeds.dfstock b/data/stockpiles/seeds.dfstock new file mode 100644 index 0000000000..ce9d0a4c22 Binary files /dev/null and b/data/stockpiles/seeds.dfstock differ diff --git a/data/stockpiles/silverweapons.dfstock b/data/stockpiles/silverweapons.dfstock new file mode 100644 index 0000000000..de517d0ab6 Binary files /dev/null and b/data/stockpiles/silverweapons.dfstock differ diff --git a/data/stockpiles/soap.dfstock b/data/stockpiles/soap.dfstock new file mode 100644 index 0000000000..0436f1e7a2 --- /dev/null +++ b/data/stockpiles/soap.dfstock @@ -0,0 +1,2 @@ +R +SOAP \ No newline at end of file diff --git a/data/stockpiles/steelarmor.dfstock b/data/stockpiles/steelarmor.dfstock new file mode 100644 index 0000000000..c2ba86fcbb Binary files /dev/null and b/data/stockpiles/steelarmor.dfstock differ diff --git a/data/stockpiles/steelbars.dfstock b/data/stockpiles/steelbars.dfstock new file mode 100644 index 0000000000..888f32e53a --- /dev/null +++ b/data/stockpiles/steelbars.dfstock @@ -0,0 +1 @@ +RINORGANIC:STEEL \ No newline at end of file diff --git a/data/stockpiles/steelweapons.dfstock b/data/stockpiles/steelweapons.dfstock new file mode 100644 index 0000000000..fc52339252 Binary files /dev/null and b/data/stockpiles/steelweapons.dfstock differ diff --git a/data/stockpiles/stonetools.dfstock b/data/stockpiles/stonetools.dfstock new file mode 100644 index 0000000000..dee961a743 --- /dev/null +++ b/data/stockpiles/stonetools.dfstock @@ -0,0 +1,2 @@ +bÆ +TOOLINORGANIC:PLASTERINORGANIC:CERAMIC_EARTHENWAREINORGANIC:CERAMIC_STONEWAREINORGANIC:CERAMIC_PORCELAININORGANIC:ASH_GLAZEINORGANIC:TIN_GLAZEINORGANIC:SANDSTONEINORGANIC:SILTSTONEINORGANIC:MUDSTONEINORGANIC:SHALEINORGANIC:CLAYSTONEINORGANIC:ROCK_SALTINORGANIC:LIMESTONEINORGANIC:CONGLOMERATEINORGANIC:DOLOMITEINORGANIC:CHERTINORGANIC:CHALKINORGANIC:GRANITEINORGANIC:DIORITEINORGANIC:GABBROINORGANIC:RHYOLITEINORGANIC:BASALTINORGANIC:ANDESITEINORGANIC:DACITEINORGANIC:OBSIDIANINORGANIC:QUARTZITEINORGANIC:SLATEINORGANIC:PHYLLITEINORGANIC:SCHISTINORGANIC:GNEISSINORGANIC:MARBLEINORGANIC:HEMATITEINORGANIC:LIMONITEINORGANIC:GARNIERITEINORGANIC:NATIVE_GOLDINORGANIC:NATIVE_SILVERINORGANIC:NATIVE_COPPERINORGANIC:MALACHITEINORGANIC:GALENAINORGANIC:SPHALERITEINORGANIC:CASSITERITEINORGANIC:COAL_BITUMINOUSINORGANIC:LIGNITEINORGANIC:NATIVE_PLATINUMINORGANIC:CINNABARINORGANIC:COBALTITEINORGANIC:TETRAHEDRITEINORGANIC:HORN_SILVERINORGANIC:GYPSUMINORGANIC:TALC INORGANIC:JETINORGANIC:PUDDINGSTONEINORGANIC:PETRIFIED_WOODINORGANIC:GRAPHITEINORGANIC:BRIMSTONEINORGANIC:KIMBERLITEINORGANIC:BISMUTHINITEINORGANIC:REALGARINORGANIC:ORPIMENTINORGANIC:STIBNITEINORGANIC:MARCASITEINORGANIC:SYLVITEINORGANIC:CRYOLITEINORGANIC:PERICLASEINORGANIC:ILMENITEINORGANIC:RUTILEINORGANIC:MAGNETITEINORGANIC:CHROMITEINORGANIC:PYROLUSITEINORGANIC:PITCHBLENDEINORGANIC:BAUXITEINORGANIC:NATIVE_ALUMINUMINORGANIC:BORAXINORGANIC:OLIVINEINORGANIC:HORNBLENDEINORGANIC:KAOLINITEINORGANIC:SERPENTINEINORGANIC:ORTHOCLASEINORGANIC:MICROCLINEINORGANIC:MICAINORGANIC:CALCITEINORGANIC:SALTPETERINORGANIC:ALABASTERINORGANIC:SELENITEINORGANIC:SATINSPARINORGANIC:ANHYDRITEINORGANIC:ALUNITEINORGANIC:RAW_ADAMANTINEINORGANIC:SLADE \ No newline at end of file diff --git a/data/stockpiles/stoneweapons.dfstock b/data/stockpiles/stoneweapons.dfstock new file mode 100644 index 0000000000..acba2374c1 Binary files /dev/null and b/data/stockpiles/stoneweapons.dfstock differ diff --git a/data/stockpiles/tannedhides.dfstock b/data/stockpiles/tannedhides.dfstock new file mode 100644 index 0000000000..9c58d41ce6 Binary files /dev/null and b/data/stockpiles/tannedhides.dfstock differ diff --git a/data/stockpiles/thread.dfstock b/data/stockpiles/thread.dfstock new file mode 100644 index 0000000000..2774f50e8a --- /dev/null +++ b/data/stockpiles/thread.dfstock @@ -0,0 +1,146 @@ +rŽ' +"CREATURE:SPIDER_BROWN_RECLUSE:SILK +&CREATURE:BROWN_RECLUSE_SPIDER_MAN:SILK +(CREATURE:GIANT_BROWN_RECLUSE_SPIDER:SILK +CREATURE:SPIDER_PHANTOM:SILK +CREATURE:SPIDER_CAVE_GIANT:SILK +CREATURE:SPIDER_CAVE:SILK +INORGANIC:DIVINE_2 +INORGANIC:DIVINE_4 +INORGANIC:DIVINE_6 +INORGANIC:DIVINE_8 +INORGANIC:DIVINE_10 +INORGANIC:DIVINE_12 +INORGANIC:DIVINE_14 +INORGANIC:DIVINE_16 +INORGANIC:DIVINE_18 +INORGANIC:DIVINE_20 +CREATURE:FORGOTTEN_BEAST_4:SILK + CREATURE:FORGOTTEN_BEAST_22:SILK + CREATURE:FORGOTTEN_BEAST_33:SILK + CREATURE:FORGOTTEN_BEAST_51:SILK + CREATURE:FORGOTTEN_BEAST_56:SILK + CREATURE:FORGOTTEN_BEAST_58:SILK + CREATURE:FORGOTTEN_BEAST_62:SILK + CREATURE:FORGOTTEN_BEAST_74:SILK + CREATURE:FORGOTTEN_BEAST_80:SILK + CREATURE:FORGOTTEN_BEAST_87:SILK + CREATURE:FORGOTTEN_BEAST_90:SILK +!CREATURE:FORGOTTEN_BEAST_106:SILK +!CREATURE:FORGOTTEN_BEAST_109:SILK +!CREATURE:FORGOTTEN_BEAST_127:SILK +!CREATURE:FORGOTTEN_BEAST_131:SILK +!CREATURE:FORGOTTEN_BEAST_143:SILK +!CREATURE:FORGOTTEN_BEAST_145:SILK +!CREATURE:FORGOTTEN_BEAST_163:SILK +!CREATURE:FORGOTTEN_BEAST_177:SILK +!CREATURE:FORGOTTEN_BEAST_189:SILK +!CREATURE:FORGOTTEN_BEAST_194:SILK +!CREATURE:FORGOTTEN_BEAST_197:SILK +!CREATURE:FORGOTTEN_BEAST_200:SILK +!CREATURE:FORGOTTEN_BEAST_201:SILK +!CREATURE:FORGOTTEN_BEAST_202:SILK +!CREATURE:FORGOTTEN_BEAST_217:SILK +!CREATURE:FORGOTTEN_BEAST_224:SILK +!CREATURE:FORGOTTEN_BEAST_234:SILK +!CREATURE:FORGOTTEN_BEAST_242:SILK +!CREATURE:FORGOTTEN_BEAST_246:SILK +!CREATURE:FORGOTTEN_BEAST_250:SILK +!CREATURE:FORGOTTEN_BEAST_270:SILK +!CREATURE:FORGOTTEN_BEAST_271:SILK +!CREATURE:FORGOTTEN_BEAST_286:SILK +!CREATURE:FORGOTTEN_BEAST_291:SILK +!CREATURE:FORGOTTEN_BEAST_296:SILK +!CREATURE:FORGOTTEN_BEAST_329:SILK +!CREATURE:FORGOTTEN_BEAST_350:SILK +!CREATURE:FORGOTTEN_BEAST_351:SILK +!CREATURE:FORGOTTEN_BEAST_359:SILK +!CREATURE:FORGOTTEN_BEAST_365:SILK +!CREATURE:FORGOTTEN_BEAST_375:SILK +!CREATURE:FORGOTTEN_BEAST_376:SILK +!CREATURE:FORGOTTEN_BEAST_377:SILK +!CREATURE:FORGOTTEN_BEAST_383:SILK +!CREATURE:FORGOTTEN_BEAST_387:SILK +!CREATURE:FORGOTTEN_BEAST_398:SILK +!CREATURE:FORGOTTEN_BEAST_400:SILK +!CREATURE:FORGOTTEN_BEAST_406:SILK +!CREATURE:FORGOTTEN_BEAST_410:SILK +!CREATURE:FORGOTTEN_BEAST_417:SILK +!CREATURE:FORGOTTEN_BEAST_428:SILK +!CREATURE:FORGOTTEN_BEAST_429:SILK +!CREATURE:FORGOTTEN_BEAST_432:SILK +!CREATURE:FORGOTTEN_BEAST_442:SILK +!CREATURE:FORGOTTEN_BEAST_448:SILK +!CREATURE:FORGOTTEN_BEAST_452:SILK +!CREATURE:FORGOTTEN_BEAST_457:SILK +!CREATURE:FORGOTTEN_BEAST_468:SILK +!CREATURE:FORGOTTEN_BEAST_472:SILK +!CREATURE:FORGOTTEN_BEAST_479:SILK +!CREATURE:FORGOTTEN_BEAST_482:SILK +!CREATURE:FORGOTTEN_BEAST_492:SILK +!CREATURE:FORGOTTEN_BEAST_504:SILK +!CREATURE:FORGOTTEN_BEAST_512:SILK +!CREATURE:FORGOTTEN_BEAST_519:SILK +!CREATURE:FORGOTTEN_BEAST_537:SILK +!CREATURE:FORGOTTEN_BEAST_550:SILK +!CREATURE:FORGOTTEN_BEAST_556:SILK +!CREATURE:FORGOTTEN_BEAST_557:SILK +!CREATURE:FORGOTTEN_BEAST_563:SILK +!CREATURE:FORGOTTEN_BEAST_573:SILK +!CREATURE:FORGOTTEN_BEAST_583:SILK +!CREATURE:FORGOTTEN_BEAST_588:SILK +!CREATURE:FORGOTTEN_BEAST_599:SILK +!CREATURE:FORGOTTEN_BEAST_602:SILK +!CREATURE:FORGOTTEN_BEAST_605:SILK +!CREATURE:FORGOTTEN_BEAST_607:SILK +!CREATURE:FORGOTTEN_BEAST_611:SILK +!CREATURE:FORGOTTEN_BEAST_618:SILK +!CREATURE:FORGOTTEN_BEAST_621:SILK +!CREATURE:FORGOTTEN_BEAST_627:SILK +!CREATURE:FORGOTTEN_BEAST_638:SILK +!CREATURE:FORGOTTEN_BEAST_639:SILK +!CREATURE:FORGOTTEN_BEAST_651:SILK +!CREATURE:FORGOTTEN_BEAST_659:SILK +!CREATURE:FORGOTTEN_BEAST_670:SILK +!CREATURE:FORGOTTEN_BEAST_686:SILK +!CREATURE:FORGOTTEN_BEAST_692:SILK +!CREATURE:FORGOTTEN_BEAST_695:SILK +!CREATURE:FORGOTTEN_BEAST_697:SILK +!CREATURE:FORGOTTEN_BEAST_699:SILK +!CREATURE:FORGOTTEN_BEAST_707:SILK +!CREATURE:FORGOTTEN_BEAST_713:SILK +!CREATURE:FORGOTTEN_BEAST_723:SILK +!CREATURE:FORGOTTEN_BEAST_733:SILK +!CREATURE:FORGOTTEN_BEAST_740:SILK +!CREATURE:FORGOTTEN_BEAST_741:SILK +!CREATURE:FORGOTTEN_BEAST_747:SILK +!CREATURE:FORGOTTEN_BEAST_758:SILK +!CREATURE:FORGOTTEN_BEAST_766:SILK +!CREATURE:FORGOTTEN_BEAST_769:SILK +!CREATURE:FORGOTTEN_BEAST_771:SILK +!CREATURE:FORGOTTEN_BEAST_790:SILK +!CREATURE:FORGOTTEN_BEAST_794:SILK +!CREATURE:FORGOTTEN_BEAST_826:SILK +!CREATURE:FORGOTTEN_BEAST_827:SILK +!CREATURE:FORGOTTEN_BEAST_837:SILK +!CREATURE:FORGOTTEN_BEAST_839:SILK +!CREATURE:FORGOTTEN_BEAST_846:SILK +!CREATURE:FORGOTTEN_BEAST_847:SILK +!CREATURE:FORGOTTEN_BEAST_849:SILK +!CREATURE:FORGOTTEN_BEAST_850:SILK +!CREATURE:FORGOTTEN_BEAST_855:SILK +CREATURE:TITAN_1:SILK +CREATURE:TITAN_5:SILK +CREATURE:TITAN_18:SILK +CREATURE:TITAN_24:SILK +CREATURE:TITAN_28:SILK +CREATURE:TITAN_29:SILK +CREATURE:TITAN_30:SILK +CREATURE:TITAN_31:SILK +CREATURE:DEMON_13:SILK +CREATURE:DEMON_15:SILK +CREATURE:DEMON_43:SILK +CREATURE:DEMON_46:SILK +CREATURE:DEMON_49:SILK +CREATURE:DEMON_50:SILK +CREATURE:DEMON_52:SILKPLANT:FLAX:THREADPLANT:JUTE:THREADPLANT:HEMP:THREADPLANT:COTTON:THREADPLANT:RAMIE:THREADPLANT:KENAF:THREADPLANT:GRASS_TAIL_PIG:THREADPLANT:REED_ROPE:THREADCREATURE:SHEEP:HAIRCREATURE:LLAMA:HAIRCREATURE:ALPACA:HAIRCREATURE:TROLL:HAIR \ No newline at end of file diff --git a/data/stockpiles/toys.dfstock b/data/stockpiles/toys.dfstock new file mode 100644 index 0000000000..a90eab591a --- /dev/null +++ b/data/stockpiles/toys.dfstock @@ -0,0 +1,2 @@ +b +TOY \ No newline at end of file diff --git a/data/stockpiles/trapcomponents.dfstock b/data/stockpiles/trapcomponents.dfstock new file mode 100644 index 0000000000..475b530d4c Binary files /dev/null and b/data/stockpiles/trapcomponents.dfstock differ diff --git a/data/stockpiles/traps.dfstock b/data/stockpiles/traps.dfstock new file mode 100644 index 0000000000..ed1ba67763 Binary files /dev/null and b/data/stockpiles/traps.dfstock differ diff --git a/data/stockpiles/unpreparedfish.dfstock b/data/stockpiles/unpreparedfish.dfstock new file mode 100644 index 0000000000..13841da901 Binary files /dev/null and b/data/stockpiles/unpreparedfish.dfstock differ diff --git a/data/stockpiles/unusablearmor.dfstock b/data/stockpiles/unusablearmor.dfstock new file mode 100644 index 0000000000..d5b2e9c649 Binary files /dev/null and b/data/stockpiles/unusablearmor.dfstock differ diff --git a/data/stockpiles/unusableweapons.dfstock b/data/stockpiles/unusableweapons.dfstock new file mode 100644 index 0000000000..6af8d1b5a2 Binary files /dev/null and b/data/stockpiles/unusableweapons.dfstock differ diff --git a/data/stockpiles/usablearmor.dfstock b/data/stockpiles/usablearmor.dfstock new file mode 100644 index 0000000000..58c9296de9 Binary files /dev/null and b/data/stockpiles/usablearmor.dfstock differ diff --git a/data/stockpiles/usablehair.dfstock b/data/stockpiles/usablehair.dfstock new file mode 100644 index 0000000000..2082d7dcf6 Binary files /dev/null and b/data/stockpiles/usablehair.dfstock differ diff --git a/data/stockpiles/usableweapons.dfstock b/data/stockpiles/usableweapons.dfstock new file mode 100644 index 0000000000..248610ae94 Binary files /dev/null and b/data/stockpiles/usableweapons.dfstock differ diff --git a/data/stockpiles/wax.dfstock b/data/stockpiles/wax.dfstock new file mode 100644 index 0000000000..35c69f6ca8 Binary files /dev/null and b/data/stockpiles/wax.dfstock differ diff --git a/data/stockpiles/woodammo.dfstock b/data/stockpiles/woodammo.dfstock new file mode 100644 index 0000000000..6bec8b1e58 --- /dev/null +++ b/data/stockpiles/woodammo.dfstock @@ -0,0 +1 @@ +BWOOD \ No newline at end of file diff --git a/data/stockpiles/woodtools.dfstock b/data/stockpiles/woodtools.dfstock new file mode 100644 index 0000000000..86eb0d0c81 --- /dev/null +++ b/data/stockpiles/woodtools.dfstock @@ -0,0 +1,2 @@ +b +TOOLWOOD \ No newline at end of file diff --git a/depends/CMakeLists.txt b/depends/CMakeLists.txt index d8442b12a5..41996294c6 100644 --- a/depends/CMakeLists.txt +++ b/depends/CMakeLists.txt @@ -1,17 +1,93 @@ -#list depends here. +# list depends here. +add_subdirectory(dfhooks) +install(TARGETS dfhooks LIBRARY DESTINATION . RUNTIME DESTINATION .) + +add_subdirectory(lodepng) add_subdirectory(lua) add_subdirectory(md5) add_subdirectory(protobuf) +target_include_directories(protobuf-lite INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/protobuf) + +if(UNIX) + set_target_properties(lua PROPERTIES COMPILE_FLAGS "-Wno-deprecated-declarations -Wno-deprecated-enum-enum-conversion") + set_target_properties(protoc PROPERTIES COMPILE_FLAGS "-Wno-deprecated-declarations -Wno-restrict") + set_target_properties(protoc-bin PROPERTIES COMPILE_FLAGS "-Wno-deprecated-declarations -Wno-restrict") + set_target_properties(protobuf-lite PROPERTIES COMPILE_FLAGS "-Wno-deprecated-declarations -Wno-restrict") + set_target_properties(protobuf PROPERTIES COMPILE_FLAGS "-Wno-deprecated-declarations -Wno-restrict") +endif() + +option(INSTALL_GTEST "Enable installation of googletest. (Projects embedding googletest may want to turn this OFF.)" OFF) +add_subdirectory(googletest) # Don't build tinyxml if it's being externally linked against. if(NOT TinyXML_FOUND) add_subdirectory(tinyxml) + target_include_directories(dfhack-tinyxml INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/tinyxml) endif() -add_subdirectory(tthread) -add_subdirectory(jsoncpp) +option(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test executables" OFF) +option(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a post build step" OFF) +option(JSONCPP_BUILD_SHARED_LIBS "Build jsoncpp_lib as a shared library." OFF) +option(JSONCPP_BUILD_OBJECT_LIBS "Build jsoncpp_lib as a object library." OFF) +option(JSONCPP_WITH_CMAKE_PACKAGE "Generate and install cmake package files" OFF) + +add_subdirectory(jsoncpp-sub EXCLUDE_FROM_ALL) # build clsocket static and only as a dependency. Setting those options here overrides its own default settings. -OPTION(CLSOCKET_SHARED "Build clsocket lib as shared." OFF) -OPTION(CLSOCKET_DEP_ONLY "Build for use inside other CMake projects as dependency." ON) +option(CLSOCKET_SHARED "Build clsocket lib as shared." OFF) +option(CLSOCKET_DEP_ONLY "Build for use inside other CMake projects as dependency." ON) add_subdirectory(clsocket) -IDE_FOLDER(clsocket "Depends") +ide_folder(clsocket "Depends") + +# set the default values of libexpat options - the descriptions are left empty +# because later option() calls *do* override those +set(EXPAT_BUILD_EXAMPLES OFF CACHE BOOL "") +set(EXPAT_BUILD_TESTS OFF CACHE BOOL "") +set(EXPAT_BUILD_TOOLS OFF CACHE BOOL "") +set(EXPAT_SHARED_LIBS OFF CACHE BOOL "") +set(EXPAT_BUILD_DOCS OFF CACHE BOOL "") +set(EXPAT_ENABLE_INSTALL OFF CACHE BOOL "") +add_subdirectory(libexpat/expat) +if(UNIX) + set_target_properties(expat PROPERTIES COMPILE_FLAGS "-Wno-maybe-uninitialized") +endif() + +set(CMAKE_REQUIRED_QUIET ON) +set(LIBZIP_BUILD_DOC OFF CACHE BOOL "") +set(LIBZIP_BUILD_EXAMPLES OFF CACHE BOOL "") +set(LIBZIP_BUILD_REGRESS OFF CACHE BOOL "") +set(LIBZIP_BUILD_SHARED_LIBS OFF CACHE BOOL "") +set(LIBZIP_BUILD_OSSFUZZ OFF CACHE BOOL "") +set(LIBZIP_BUILD_TOOLS OFF CACHE BOOL "") +set(LIBZIP_ENABLE_BZIP2 OFF CACHE BOOL "") +set(LIBZIP_ENABLE_COMMONCRYPTO OFF CACHE BOOL "") +set(LIBZIP_ENABLE_GNUTLS OFF CACHE BOOL "") +set(LIBZIP_ENABLE_LZMA OFF CACHE BOOL "") +set(LIBZIP_ENABLE_MBEDTLS OFF CACHE BOOL "") +set(LIBZIP_ENABLE_OPENSSL OFF CACHE BOOL "") +set(LIBZIP_ENABLE_WINDOWS_CRYPTO OFF CACHE BOOL "") +set(LIBZIP_DO_INSTALL OFF CACHE BOOL "") +add_subdirectory(libzip) +if(MSVC) + target_compile_options(zip PRIVATE /wd4244) +elseif(UNIX) + set_target_properties(zip PROPERTIES COMPILE_FLAGS "-Wno-stringop-truncation -Wno-stringop-overflow") +endif() + +set(XLSXIO_USE_DFHACK_LIBS ON CACHE BOOL "") +set(XLSXIO_BUILD_STATIC ON CACHE BOOL "") +set(XLSXIO_BUILD_SHARED OFF CACHE BOOL "") +set(XLSXIO_BUILD_DOCUMENTATION OFF CACHE BOOL "") +set(XLSXIO_BUILD_EXAMPLES OFF CACHE BOOL "") +set(XLSXIO_BUILD_TOOLS OFF CACHE BOOL "") +set(XLSXIO_WITH_LIBZIP ON CACHE BOOL "") +set(XLSXIO_ZLIB_DIR "${ZLIB_DIR}" CACHE PATH "") +set(XLSXIO_LIBZIP_DIR "${CMAKE_CURRENT_BINARY_DIR}/libzip" CACHE PATH "") +set(XLSXIO_EXPAT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libexpat" CACHE PATH "") +set(XLSXIO_ENABLE_INSTALL OFF CACHE BOOL "") +add_subdirectory(xlsxio) +if(MSVC) + target_compile_options(xlsxio_read_STATIC PRIVATE /wd4013 /wd4244) + target_compile_options(xlsxio_write_STATIC PRIVATE /wd4013 /wd4244) +endif() +target_include_directories(xlsxio_read_STATIC INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/xlsxio/include) +target_include_directories(xlsxio_write_STATIC INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/xlsxio/include) diff --git a/depends/clsocket b/depends/clsocket index b08d765a7d..00c3267aac 160000 --- a/depends/clsocket +++ b/depends/clsocket @@ -1 +1 @@ -Subproject commit b08d765a7ddacf66693cb2721833b3b56b092aa3 +Subproject commit 00c3267aacc9c10c5864c7fce856df0de52d72a8 diff --git a/depends/copy-if-different.pl b/depends/copy-if-different.pl new file mode 100755 index 0000000000..2ba08a80e1 --- /dev/null +++ b/depends/copy-if-different.pl @@ -0,0 +1,30 @@ +#!/usr/bin/perl + +# A replacement for "cmake -E copy_if_different" that supports multiple files, +# which old cmake versions do not support + +# Usage: copy-if-different.pl src-file [src-file...] dest-dir + +use strict; +use warnings; + +use Digest::SHA; +use File::Basename; +use File::Copy; + +sub sha_file { + my $filename = shift; + my $sha = Digest::SHA->new(256); + $sha->addfile($filename); + return $sha->hexdigest; +} + +my $dest_dir = pop @ARGV or die "no destination dir"; +-d $dest_dir or die "not a directory: $dest_dir"; +my @src_files = @ARGV or die "no source files"; + +foreach my $file (@src_files) { + my $dest = "$dest_dir/" . basename($file); + next if -f $dest && sha_file($file) eq sha_file($dest); + copy($file, $dest); +} diff --git a/depends/dfhooks b/depends/dfhooks new file mode 160000 index 0000000000..5a904e30a8 --- /dev/null +++ b/depends/dfhooks @@ -0,0 +1 @@ +Subproject commit 5a904e30a8bace81c662b44ec7ff076b92edafd1 diff --git a/depends/googletest b/depends/googletest new file mode 160000 index 0000000000..b514bdc898 --- /dev/null +++ b/depends/googletest @@ -0,0 +1 @@ +Subproject commit b514bdc898e2951020cbdca1304b75f5950d1f59 diff --git a/depends/gunzip.pl b/depends/gunzip.pl new file mode 100755 index 0000000000..caabad5a84 --- /dev/null +++ b/depends/gunzip.pl @@ -0,0 +1,21 @@ +#!/usr/bin/perl + +use strict; +use warnings; + +use IO::Uncompress::Gunzip qw(gunzip $GunzipError); + +my %args = map { $_ => 1 } @ARGV; + +my $in_file = $ARGV[0] or die "no input file"; +# remove extension +(my $out_file = $in_file) =~ s{\.[^.]+$}{}; + +if (! -f $in_file) { + die "input file does not exist: \"$in_file\"\n"; +} +if (-f $out_file and !exists($args{'--force'})) { + die "output file exists, not overwriting: \"$out_file\""; +} + +gunzip $in_file => $out_file, BinModeOut => 1 or die "gunzip failed: $GunzipError\n"; diff --git a/depends/jsoncpp-sub b/depends/jsoncpp-sub new file mode 160000 index 0000000000..3a5d4ff058 --- /dev/null +++ b/depends/jsoncpp-sub @@ -0,0 +1 @@ +Subproject commit 3a5d4ff0583ce7dd5abbf92bdf49dca2177459ef diff --git a/depends/jsoncpp/CMakeLists.txt b/depends/jsoncpp/CMakeLists.txt deleted file mode 100644 index 112903ee3c..0000000000 --- a/depends/jsoncpp/CMakeLists.txt +++ /dev/null @@ -1,2 +0,0 @@ -PROJECT(jsoncpp) -ADD_LIBRARY(jsoncpp STATIC jsoncpp.cpp) diff --git a/depends/jsoncpp/jsoncpp.cpp b/depends/jsoncpp/jsoncpp.cpp deleted file mode 100644 index eb38217ef7..0000000000 --- a/depends/jsoncpp/jsoncpp.cpp +++ /dev/null @@ -1,5089 +0,0 @@ -/// Json-cpp amalgated source (http://jsoncpp.sourceforge.net/). -/// It is intended to be used with #include "json/json.h" - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: LICENSE -// ////////////////////////////////////////////////////////////////////// - -/* -The JsonCpp library's source code, including accompanying documentation, -tests and demonstration applications, are licensed under the following -conditions... - -The author (Baptiste Lepilleur) explicitly disclaims copyright in all -jurisdictions which recognize such a disclaimer. In such jurisdictions, -this software is released into the Public Domain. - -In jurisdictions which do not recognize Public Domain property (e.g. Germany as of -2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is -released under the terms of the MIT License (see below). - -In jurisdictions which recognize Public Domain property, the user of this -software may choose to accept it either as 1) Public Domain, 2) under the -conditions of the MIT License (see below), or 3) under the terms of dual -Public Domain/MIT License conditions described here, as they choose. - -The MIT License is about as close to Public Domain as a license can get, and is -described in clear, concise terms at: - - http://en.wikipedia.org/wiki/MIT_License - -The full text of the MIT License follows: - -======================================================================== -Copyright (c) 2007-2010 Baptiste Lepilleur - -Permission is hereby granted, free of charge, to any person -obtaining a copy of this software and associated documentation -files (the "Software"), to deal in the Software without -restriction, including without limitation the rights to use, copy, -modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS -BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN -ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -======================================================================== -(END LICENSE TEXT) - -The MIT license is compatible with both the GPL and commercial -software, affording one all of the rights of Public Domain with the -minor nuisance of being required to keep the above copyright notice -and license text in the source code. Note also that by accepting the -Public Domain "license" you can re-license your copy using whatever -license you like. - -*/ - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: LICENSE -// ////////////////////////////////////////////////////////////////////// - - - - - - -#include "jsoncpp.h" - -#ifndef JSON_IS_AMALGAMATION -#error "Compile with -I PATH_TO_JSON_DIRECTORY" -#endif - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: src/lib_json/json_tool.h -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED -#define LIB_JSONCPP_JSON_TOOL_H_INCLUDED - -/* This header provides common string manipulation support, such as UTF-8, - * portable conversion from/to string... - * - * It is an internal header that must not be exposed. - */ - -namespace Json { - -/// Converts a unicode code-point to UTF-8. -static inline std::string codePointToUTF8(unsigned int cp) { - std::string result; - - // based on description from http://en.wikipedia.org/wiki/UTF-8 - - if (cp <= 0x7f) { - result.resize(1); - result[0] = static_cast(cp); - } else if (cp <= 0x7FF) { - result.resize(2); - result[1] = static_cast(0x80 | (0x3f & cp)); - result[0] = static_cast(0xC0 | (0x1f & (cp >> 6))); - } else if (cp <= 0xFFFF) { - result.resize(3); - result[2] = static_cast(0x80 | (0x3f & cp)); - result[1] = static_cast(0x80 | (0x3f & (cp >> 6))); - result[0] = static_cast(0xE0 | (0xf & (cp >> 12))); - } else if (cp <= 0x10FFFF) { - result.resize(4); - result[3] = static_cast(0x80 | (0x3f & cp)); - result[2] = static_cast(0x80 | (0x3f & (cp >> 6))); - result[1] = static_cast(0x80 | (0x3f & (cp >> 12))); - result[0] = static_cast(0xF0 | (0x7 & (cp >> 18))); - } - - return result; -} - -/// Returns true if ch is a control character (in range [1,31]). -static inline bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; } - -enum { - /// Constant that specify the size of the buffer that must be passed to - /// uintToString. - uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1 -}; - -// Defines a char buffer for use with uintToString(). -typedef char UIntToStringBuffer[uintToStringBufferSize]; - -/** Converts an unsigned integer to string. - * @param value Unsigned interger to convert to string - * @param current Input/Output string buffer. - * Must have at least uintToStringBufferSize chars free. - */ -static inline void uintToString(LargestUInt value, char*& current) { - *--current = 0; - do { - *--current = static_cast(value % 10U + static_cast('0')); - value /= 10; - } while (value != 0); -} - -/** Change ',' to '.' everywhere in buffer. - * - * We had a sophisticated way, but it did not work in WinCE. - * @see https://github.com/open-source-parsers/jsoncpp/pull/9 - */ -static inline void fixNumericLocale(char* begin, char* end) { - while (begin < end) { - if (*begin == ',') { - *begin = '.'; - } - ++begin; - } -} - -} // namespace Json { - -#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: src/lib_json/json_tool.h -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: src/lib_json/json_reader.cpp -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2011 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#if !defined(JSON_IS_AMALGAMATION) -#include -#include -#include -#include "json_tool.h" -#endif // if !defined(JSON_IS_AMALGAMATION) -#include -#include -#include -#include -#include -#include -#include -#include - -#if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below -#define snprintf _snprintf -#endif - -#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0 -// Disable warning about strdup being deprecated. -#pragma warning(disable : 4996) -#endif - -static int const stackLimit_g = 1000; -static int stackDepth_g = 0; // see readValue() - -namespace Json { - -#if __cplusplus >= 201103L -typedef std::unique_ptr CharReaderPtr; -#else -typedef std::auto_ptr CharReaderPtr; -#endif - -// Implementation of class Features -// //////////////////////////////// - -Features::Features() - : allowComments_(true), strictRoot_(false), - allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) {} - -Features Features::all() { return Features(); } - -Features Features::strictMode() { - Features features; - features.allowComments_ = false; - features.strictRoot_ = true; - features.allowDroppedNullPlaceholders_ = false; - features.allowNumericKeys_ = false; - return features; -} - -// Implementation of class Reader -// //////////////////////////////// - -static bool containsNewLine(Reader::Location begin, Reader::Location end) { - for (; begin < end; ++begin) - if (*begin == '\n' || *begin == '\r') - return true; - return false; -} - -// Class Reader -// ////////////////////////////////////////////////////////////////// - -Reader::Reader() - : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(), - lastValue_(), commentsBefore_(), features_(Features::all()), - collectComments_() {} - -Reader::Reader(const Features& features) - : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(), - lastValue_(), commentsBefore_(), features_(features), collectComments_() { -} - -bool -Reader::parse(const std::string& document, Value& root, bool collectComments) { - document_ = document; - const char* begin = document_.c_str(); - const char* end = begin + document_.length(); - return parse(begin, end, root, collectComments); -} - -bool Reader::parse(std::istream& sin, Value& root, bool collectComments) { - // std::istream_iterator begin(sin); - // std::istream_iterator end; - // Those would allow streamed input from a file, if parse() were a - // template function. - - // Since std::string is reference-counted, this at least does not - // create an extra copy. - std::string doc; - std::getline(sin, doc, (char)EOF); - return parse(doc, root, collectComments); -} - -bool Reader::parse(const char* beginDoc, - const char* endDoc, - Value& root, - bool collectComments) { - if (!features_.allowComments_) { - collectComments = false; - } - - begin_ = beginDoc; - end_ = endDoc; - collectComments_ = collectComments; - current_ = begin_; - lastValueEnd_ = 0; - lastValue_ = 0; - commentsBefore_ = ""; - errors_.clear(); - while (!nodes_.empty()) - nodes_.pop(); - nodes_.push(&root); - - stackDepth_g = 0; // Yes, this is bad coding, but options are limited. - bool successful = readValue(); - Token token; - skipCommentTokens(token); - if (collectComments_ && !commentsBefore_.empty()) - root.setComment(commentsBefore_, commentAfter); - if (features_.strictRoot_) { - if (!root.isArray() && !root.isObject()) { - // Set error location to start of doc, ideally should be first token found - // in doc - token.type_ = tokenError; - token.start_ = beginDoc; - token.end_ = endDoc; - addError( - "A valid JSON document must be either an array or an object value.", - token); - return false; - } - } - return successful; -} - -bool Reader::readValue() { - // This is a non-reentrant way to support a stackLimit. Terrible! - // But this deprecated class has a security problem: Bad input can - // cause a seg-fault. This seems like a fair, binary-compatible way - // to prevent the problem. - if (stackDepth_g >= stackLimit_g) throwRuntimeError("Exceeded stackLimit in readValue()."); - ++stackDepth_g; - - Token token; - skipCommentTokens(token); - bool successful = true; - - if (collectComments_ && !commentsBefore_.empty()) { - currentValue().setComment(commentsBefore_, commentBefore); - commentsBefore_ = ""; - } - - switch (token.type_) { - case tokenObjectBegin: - successful = readObject(token); - currentValue().setOffsetLimit(current_ - begin_); - break; - case tokenArrayBegin: - successful = readArray(token); - currentValue().setOffsetLimit(current_ - begin_); - break; - case tokenNumber: - successful = decodeNumber(token); - break; - case tokenString: - successful = decodeString(token); - break; - case tokenTrue: - { - Value v(true); - currentValue().swapPayload(v); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - } - break; - case tokenFalse: - { - Value v(false); - currentValue().swapPayload(v); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - } - break; - case tokenNull: - { - Value v; - currentValue().swapPayload(v); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - } - break; - case tokenArraySeparator: - case tokenObjectEnd: - case tokenArrayEnd: - if (features_.allowDroppedNullPlaceholders_) { - // "Un-read" the current token and mark the current value as a null - // token. - current_--; - Value v; - currentValue().swapPayload(v); - currentValue().setOffsetStart(current_ - begin_ - 1); - currentValue().setOffsetLimit(current_ - begin_); - break; - } // Else, fall through... - default: - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - return addError("Syntax error: value, object or array expected.", token); - } - - if (collectComments_) { - lastValueEnd_ = current_; - lastValue_ = ¤tValue(); - } - - --stackDepth_g; - return successful; -} - -void Reader::skipCommentTokens(Token& token) { - if (features_.allowComments_) { - do { - readToken(token); - } while (token.type_ == tokenComment); - } else { - readToken(token); - } -} - -bool Reader::readToken(Token& token) { - skipSpaces(); - token.start_ = current_; - Char c = getNextChar(); - bool ok = true; - switch (c) { - case '{': - token.type_ = tokenObjectBegin; - break; - case '}': - token.type_ = tokenObjectEnd; - break; - case '[': - token.type_ = tokenArrayBegin; - break; - case ']': - token.type_ = tokenArrayEnd; - break; - case '"': - token.type_ = tokenString; - ok = readString(); - break; - case '/': - token.type_ = tokenComment; - ok = readComment(); - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - case '-': - token.type_ = tokenNumber; - readNumber(); - break; - case 't': - token.type_ = tokenTrue; - ok = match("rue", 3); - break; - case 'f': - token.type_ = tokenFalse; - ok = match("alse", 4); - break; - case 'n': - token.type_ = tokenNull; - ok = match("ull", 3); - break; - case ',': - token.type_ = tokenArraySeparator; - break; - case ':': - token.type_ = tokenMemberSeparator; - break; - case 0: - token.type_ = tokenEndOfStream; - break; - default: - ok = false; - break; - } - if (!ok) - token.type_ = tokenError; - token.end_ = current_; - return true; -} - -void Reader::skipSpaces() { - while (current_ != end_) { - Char c = *current_; - if (c == ' ' || c == '\t' || c == '\r' || c == '\n') - ++current_; - else - break; - } -} - -bool Reader::match(Location pattern, int patternLength) { - if (end_ - current_ < patternLength) - return false; - int index = patternLength; - while (index--) - if (current_[index] != pattern[index]) - return false; - current_ += patternLength; - return true; -} - -bool Reader::readComment() { - Location commentBegin = current_ - 1; - Char c = getNextChar(); - bool successful = false; - if (c == '*') - successful = readCStyleComment(); - else if (c == '/') - successful = readCppStyleComment(); - if (!successful) - return false; - - if (collectComments_) { - CommentPlacement placement = commentBefore; - if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) { - if (c != '*' || !containsNewLine(commentBegin, current_)) - placement = commentAfterOnSameLine; - } - - addComment(commentBegin, current_, placement); - } - return true; -} - -static std::string normalizeEOL(Reader::Location begin, Reader::Location end) { - std::string normalized; - normalized.reserve(end - begin); - Reader::Location current = begin; - while (current != end) { - char c = *current++; - if (c == '\r') { - if (current != end && *current == '\n') - // convert dos EOL - ++current; - // convert Mac EOL - normalized += '\n'; - } else { - normalized += c; - } - } - return normalized; -} - -void -Reader::addComment(Location begin, Location end, CommentPlacement placement) { - assert(collectComments_); - const std::string& normalized = normalizeEOL(begin, end); - if (placement == commentAfterOnSameLine) { - assert(lastValue_ != 0); - lastValue_->setComment(normalized, placement); - } else { - commentsBefore_ += normalized; - } -} - -bool Reader::readCStyleComment() { - while (current_ != end_) { - Char c = getNextChar(); - if (c == '*' && *current_ == '/') - break; - } - return getNextChar() == '/'; -} - -bool Reader::readCppStyleComment() { - while (current_ != end_) { - Char c = getNextChar(); - if (c == '\n') - break; - if (c == '\r') { - // Consume DOS EOL. It will be normalized in addComment. - if (current_ != end_ && *current_ == '\n') - getNextChar(); - // Break on Moc OS 9 EOL. - break; - } - } - return true; -} - -void Reader::readNumber() { - const char *p = current_; - char c = '0'; // stopgap for already consumed character - // integral part - while (c >= '0' && c <= '9') - c = (current_ = p) < end_ ? *p++ : 0; - // fractional part - if (c == '.') { - c = (current_ = p) < end_ ? *p++ : 0; - while (c >= '0' && c <= '9') - c = (current_ = p) < end_ ? *p++ : 0; - } - // exponential part - if (c == 'e' || c == 'E') { - c = (current_ = p) < end_ ? *p++ : 0; - if (c == '+' || c == '-') - c = (current_ = p) < end_ ? *p++ : 0; - while (c >= '0' && c <= '9') - c = (current_ = p) < end_ ? *p++ : 0; - } -} - -bool Reader::readString() { - Char c = 0; - while (current_ != end_) { - c = getNextChar(); - if (c == '\\') - getNextChar(); - else if (c == '"') - break; - } - return c == '"'; -} - -bool Reader::readObject(Token& tokenStart) { - Token tokenName; - std::string name; - Value init(objectValue); - currentValue().swapPayload(init); - currentValue().setOffsetStart(tokenStart.start_ - begin_); - while (readToken(tokenName)) { - bool initialTokenOk = true; - while (tokenName.type_ == tokenComment && initialTokenOk) - initialTokenOk = readToken(tokenName); - if (!initialTokenOk) - break; - if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object - return true; - name = ""; - if (tokenName.type_ == tokenString) { - if (!decodeString(tokenName, name)) - return recoverFromError(tokenObjectEnd); - } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) { - Value numberName; - if (!decodeNumber(tokenName, numberName)) - return recoverFromError(tokenObjectEnd); - name = numberName.asString(); - } else { - break; - } - - Token colon; - if (!readToken(colon) || colon.type_ != tokenMemberSeparator) { - return addErrorAndRecover( - "Missing ':' after object member name", colon, tokenObjectEnd); - } - Value& value = currentValue()[name]; - nodes_.push(&value); - bool ok = readValue(); - nodes_.pop(); - if (!ok) // error already set - return recoverFromError(tokenObjectEnd); - - Token comma; - if (!readToken(comma) || - (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator && - comma.type_ != tokenComment)) { - return addErrorAndRecover( - "Missing ',' or '}' in object declaration", comma, tokenObjectEnd); - } - bool finalizeTokenOk = true; - while (comma.type_ == tokenComment && finalizeTokenOk) - finalizeTokenOk = readToken(comma); - if (comma.type_ == tokenObjectEnd) - return true; - } - return addErrorAndRecover( - "Missing '}' or object member name", tokenName, tokenObjectEnd); -} - -bool Reader::readArray(Token& tokenStart) { - Value init(arrayValue); - currentValue().swapPayload(init); - currentValue().setOffsetStart(tokenStart.start_ - begin_); - skipSpaces(); - if (*current_ == ']') // empty array - { - Token endArray; - readToken(endArray); - return true; - } - int index = 0; - for (;;) { - Value& value = currentValue()[index++]; - nodes_.push(&value); - bool ok = readValue(); - nodes_.pop(); - if (!ok) // error already set - return recoverFromError(tokenArrayEnd); - - Token token; - // Accept Comment after last item in the array. - ok = readToken(token); - while (token.type_ == tokenComment && ok) { - ok = readToken(token); - } - bool badTokenType = - (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd); - if (!ok || badTokenType) { - return addErrorAndRecover( - "Missing ',' or ']' in array declaration", token, tokenArrayEnd); - } - if (token.type_ == tokenArrayEnd) - break; - } - return true; -} - -bool Reader::decodeNumber(Token& token) { - Value decoded; - if (!decodeNumber(token, decoded)) - return false; - currentValue().swapPayload(decoded); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - return true; -} - -bool Reader::decodeNumber(Token& token, Value& decoded) { - // Attempts to parse the number as an integer. If the number is - // larger than the maximum supported value of an integer then - // we decode the number as a double. - Location current = token.start_; - bool isNegative = *current == '-'; - if (isNegative) - ++current; - // TODO: Help the compiler do the div and mod at compile time or get rid of them. - Value::LargestUInt maxIntegerValue = - isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1 - : Value::maxLargestUInt; - Value::LargestUInt threshold = maxIntegerValue / 10; - Value::LargestUInt value = 0; - while (current < token.end_) { - Char c = *current++; - if (c < '0' || c > '9') - return decodeDouble(token, decoded); - Value::UInt digit(c - '0'); - if (value >= threshold) { - // We've hit or exceeded the max value divided by 10 (rounded down). If - // a) we've only just touched the limit, b) this is the last digit, and - // c) it's small enough to fit in that rounding delta, we're okay. - // Otherwise treat this number as a double to avoid overflow. - if (value > threshold || current != token.end_ || - digit > maxIntegerValue % 10) { - return decodeDouble(token, decoded); - } - } - value = value * 10 + digit; - } - if (isNegative && value == maxIntegerValue) - decoded = Value::minLargestInt; - else if (isNegative) - decoded = -Value::LargestInt(value); - else if (value <= Value::LargestUInt(Value::maxInt)) - decoded = Value::LargestInt(value); - else - decoded = value; - return true; -} - -bool Reader::decodeDouble(Token& token) { - Value decoded; - if (!decodeDouble(token, decoded)) - return false; - currentValue().swapPayload(decoded); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - return true; -} - -bool Reader::decodeDouble(Token& token, Value& decoded) { - double value = 0; - std::string buffer(token.start_, token.end_); - std::istringstream is(buffer); - if (!(is >> value)) - return addError("'" + std::string(token.start_, token.end_) + - "' is not a number.", - token); - decoded = value; - return true; -} - -bool Reader::decodeString(Token& token) { - std::string decoded_string; - if (!decodeString(token, decoded_string)) - return false; - Value decoded(decoded_string); - currentValue().swapPayload(decoded); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - return true; -} - -bool Reader::decodeString(Token& token, std::string& decoded) { - decoded.reserve(token.end_ - token.start_ - 2); - Location current = token.start_ + 1; // skip '"' - Location end = token.end_ - 1; // do not include '"' - while (current != end) { - Char c = *current++; - if (c == '"') - break; - else if (c == '\\') { - if (current == end) - return addError("Empty escape sequence in string", token, current); - Char escape = *current++; - switch (escape) { - case '"': - decoded += '"'; - break; - case '/': - decoded += '/'; - break; - case '\\': - decoded += '\\'; - break; - case 'b': - decoded += '\b'; - break; - case 'f': - decoded += '\f'; - break; - case 'n': - decoded += '\n'; - break; - case 'r': - decoded += '\r'; - break; - case 't': - decoded += '\t'; - break; - case 'u': { - unsigned int unicode; - if (!decodeUnicodeCodePoint(token, current, end, unicode)) - return false; - decoded += codePointToUTF8(unicode); - } break; - default: - return addError("Bad escape sequence in string", token, current); - } - } else { - decoded += c; - } - } - return true; -} - -bool Reader::decodeUnicodeCodePoint(Token& token, - Location& current, - Location end, - unsigned int& unicode) { - - if (!decodeUnicodeEscapeSequence(token, current, end, unicode)) - return false; - if (unicode >= 0xD800 && unicode <= 0xDBFF) { - // surrogate pairs - if (end - current < 6) - return addError( - "additional six characters expected to parse unicode surrogate pair.", - token, - current); - unsigned int surrogatePair; - if (*(current++) == '\\' && *(current++) == 'u') { - if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) { - unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF); - } else - return false; - } else - return addError("expecting another \\u token to begin the second half of " - "a unicode surrogate pair", - token, - current); - } - return true; -} - -bool Reader::decodeUnicodeEscapeSequence(Token& token, - Location& current, - Location end, - unsigned int& unicode) { - if (end - current < 4) - return addError( - "Bad unicode escape sequence in string: four digits expected.", - token, - current); - unicode = 0; - for (int index = 0; index < 4; ++index) { - Char c = *current++; - unicode *= 16; - if (c >= '0' && c <= '9') - unicode += c - '0'; - else if (c >= 'a' && c <= 'f') - unicode += c - 'a' + 10; - else if (c >= 'A' && c <= 'F') - unicode += c - 'A' + 10; - else - return addError( - "Bad unicode escape sequence in string: hexadecimal digit expected.", - token, - current); - } - return true; -} - -bool -Reader::addError(const std::string& message, Token& token, Location extra) { - ErrorInfo info; - info.token_ = token; - info.message_ = message; - info.extra_ = extra; - errors_.push_back(info); - return false; -} - -bool Reader::recoverFromError(TokenType skipUntilToken) { - int errorCount = int(errors_.size()); - Token skip; - for (;;) { - if (!readToken(skip)) - errors_.resize(errorCount); // discard errors caused by recovery - if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream) - break; - } - errors_.resize(errorCount); - return false; -} - -bool Reader::addErrorAndRecover(const std::string& message, - Token& token, - TokenType skipUntilToken) { - addError(message, token); - return recoverFromError(skipUntilToken); -} - -Value& Reader::currentValue() { return *(nodes_.top()); } - -Reader::Char Reader::getNextChar() { - if (current_ == end_) - return 0; - return *current_++; -} - -void Reader::getLocationLineAndColumn(Location location, - int& line, - int& column) const { - Location current = begin_; - Location lastLineStart = current; - line = 0; - while (current < location && current != end_) { - Char c = *current++; - if (c == '\r') { - if (*current == '\n') - ++current; - lastLineStart = current; - ++line; - } else if (c == '\n') { - lastLineStart = current; - ++line; - } - } - // column & line start at 1 - column = int(location - lastLineStart) + 1; - ++line; -} - -std::string Reader::getLocationLineAndColumn(Location location) const { - int line, column; - getLocationLineAndColumn(location, line, column); - char buffer[18 + 16 + 16 + 1]; -#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) -#if defined(WINCE) - _snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column); -#else - sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column); -#endif -#else - snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column); -#endif - return buffer; -} - -// Deprecated. Preserved for backward compatibility -std::string Reader::getFormatedErrorMessages() const { - return getFormattedErrorMessages(); -} - -std::string Reader::getFormattedErrorMessages() const { - std::string formattedMessage; - for (Errors::const_iterator itError = errors_.begin(); - itError != errors_.end(); - ++itError) { - const ErrorInfo& error = *itError; - formattedMessage += - "* " + getLocationLineAndColumn(error.token_.start_) + "\n"; - formattedMessage += " " + error.message_ + "\n"; - if (error.extra_) - formattedMessage += - "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n"; - } - return formattedMessage; -} - -std::vector Reader::getStructuredErrors() const { - std::vector allErrors; - for (Errors::const_iterator itError = errors_.begin(); - itError != errors_.end(); - ++itError) { - const ErrorInfo& error = *itError; - Reader::StructuredError structured; - structured.offset_start = error.token_.start_ - begin_; - structured.offset_limit = error.token_.end_ - begin_; - structured.message = error.message_; - allErrors.push_back(structured); - } - return allErrors; -} - -bool Reader::pushError(const Value& value, const std::string& message) { - size_t length = end_ - begin_; - if(value.getOffsetStart() > length - || value.getOffsetLimit() > length) - return false; - Token token; - token.type_ = tokenError; - token.start_ = begin_ + value.getOffsetStart(); - token.end_ = end_ + value.getOffsetLimit(); - ErrorInfo info; - info.token_ = token; - info.message_ = message; - info.extra_ = 0; - errors_.push_back(info); - return true; -} - -bool Reader::pushError(const Value& value, const std::string& message, const Value& extra) { - size_t length = end_ - begin_; - if(value.getOffsetStart() > length - || value.getOffsetLimit() > length - || extra.getOffsetLimit() > length) - return false; - Token token; - token.type_ = tokenError; - token.start_ = begin_ + value.getOffsetStart(); - token.end_ = begin_ + value.getOffsetLimit(); - ErrorInfo info; - info.token_ = token; - info.message_ = message; - info.extra_ = begin_ + extra.getOffsetStart(); - errors_.push_back(info); - return true; -} - -bool Reader::good() const { - return !errors_.size(); -} - -// exact copy of Features -class OurFeatures { -public: - static OurFeatures all(); - OurFeatures(); - bool allowComments_; - bool strictRoot_; - bool allowDroppedNullPlaceholders_; - bool allowNumericKeys_; - bool allowSingleQuotes_; - bool failIfExtra_; - bool rejectDupKeys_; - int stackLimit_; -}; // OurFeatures - -// exact copy of Implementation of class Features -// //////////////////////////////// - -OurFeatures::OurFeatures() - : allowComments_(true), strictRoot_(false) - , allowDroppedNullPlaceholders_(false), allowNumericKeys_(false) - , allowSingleQuotes_(false) - , failIfExtra_(false) -{ -} - -OurFeatures OurFeatures::all() { return OurFeatures(); } - -// Implementation of class Reader -// //////////////////////////////// - -// exact copy of Reader, renamed to OurReader -class OurReader { -public: - typedef char Char; - typedef const Char* Location; - struct StructuredError { - size_t offset_start; - size_t offset_limit; - std::string message; - }; - - OurReader(OurFeatures const& features); - bool parse(const char* beginDoc, - const char* endDoc, - Value& root, - bool collectComments = true); - std::string getFormattedErrorMessages() const; - std::vector getStructuredErrors() const; - bool pushError(const Value& value, const std::string& message); - bool pushError(const Value& value, const std::string& message, const Value& extra); - bool good() const; - -private: - OurReader(OurReader const&); // no impl - void operator=(OurReader const&); // no impl - - enum TokenType { - tokenEndOfStream = 0, - tokenObjectBegin, - tokenObjectEnd, - tokenArrayBegin, - tokenArrayEnd, - tokenString, - tokenNumber, - tokenTrue, - tokenFalse, - tokenNull, - tokenArraySeparator, - tokenMemberSeparator, - tokenComment, - tokenError - }; - - class Token { - public: - TokenType type_; - Location start_; - Location end_; - }; - - class ErrorInfo { - public: - Token token_; - std::string message_; - Location extra_; - }; - - typedef std::deque Errors; - - bool readToken(Token& token); - void skipSpaces(); - bool match(Location pattern, int patternLength); - bool readComment(); - bool readCStyleComment(); - bool readCppStyleComment(); - bool readString(); - bool readStringSingleQuote(); - void readNumber(); - bool readValue(); - bool readObject(Token& token); - bool readArray(Token& token); - bool decodeNumber(Token& token); - bool decodeNumber(Token& token, Value& decoded); - bool decodeString(Token& token); - bool decodeString(Token& token, std::string& decoded); - bool decodeDouble(Token& token); - bool decodeDouble(Token& token, Value& decoded); - bool decodeUnicodeCodePoint(Token& token, - Location& current, - Location end, - unsigned int& unicode); - bool decodeUnicodeEscapeSequence(Token& token, - Location& current, - Location end, - unsigned int& unicode); - bool addError(const std::string& message, Token& token, Location extra = 0); - bool recoverFromError(TokenType skipUntilToken); - bool addErrorAndRecover(const std::string& message, - Token& token, - TokenType skipUntilToken); - void skipUntilSpace(); - Value& currentValue(); - Char getNextChar(); - void - getLocationLineAndColumn(Location location, int& line, int& column) const; - std::string getLocationLineAndColumn(Location location) const; - void addComment(Location begin, Location end, CommentPlacement placement); - void skipCommentTokens(Token& token); - - typedef std::stack Nodes; - Nodes nodes_; - Errors errors_; - std::string document_; - Location begin_; - Location end_; - Location current_; - Location lastValueEnd_; - Value* lastValue_; - std::string commentsBefore_; - int stackDepth_; - - OurFeatures const features_; - bool collectComments_; -}; // OurReader - -// complete copy of Read impl, for OurReader - -OurReader::OurReader(OurFeatures const& features) - : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(), - lastValue_(), commentsBefore_(), features_(features), collectComments_() { -} - -bool OurReader::parse(const char* beginDoc, - const char* endDoc, - Value& root, - bool collectComments) { - if (!features_.allowComments_) { - collectComments = false; - } - - begin_ = beginDoc; - end_ = endDoc; - collectComments_ = collectComments; - current_ = begin_; - lastValueEnd_ = 0; - lastValue_ = 0; - commentsBefore_ = ""; - errors_.clear(); - while (!nodes_.empty()) - nodes_.pop(); - nodes_.push(&root); - - stackDepth_ = 0; - bool successful = readValue(); - Token token; - skipCommentTokens(token); - if (features_.failIfExtra_) { - if (token.type_ != tokenError && token.type_ != tokenEndOfStream) { - addError("Extra non-whitespace after JSON value.", token); - return false; - } - } - if (collectComments_ && !commentsBefore_.empty()) - root.setComment(commentsBefore_, commentAfter); - if (features_.strictRoot_) { - if (!root.isArray() && !root.isObject()) { - // Set error location to start of doc, ideally should be first token found - // in doc - token.type_ = tokenError; - token.start_ = beginDoc; - token.end_ = endDoc; - addError( - "A valid JSON document must be either an array or an object value.", - token); - return false; - } - } - return successful; -} - -bool OurReader::readValue() { - if (stackDepth_ >= features_.stackLimit_) throwRuntimeError("Exceeded stackLimit in readValue()."); - ++stackDepth_; - Token token; - skipCommentTokens(token); - bool successful = true; - - if (collectComments_ && !commentsBefore_.empty()) { - currentValue().setComment(commentsBefore_, commentBefore); - commentsBefore_ = ""; - } - - switch (token.type_) { - case tokenObjectBegin: - successful = readObject(token); - currentValue().setOffsetLimit(current_ - begin_); - break; - case tokenArrayBegin: - successful = readArray(token); - currentValue().setOffsetLimit(current_ - begin_); - break; - case tokenNumber: - successful = decodeNumber(token); - break; - case tokenString: - successful = decodeString(token); - break; - case tokenTrue: - { - Value v(true); - currentValue().swapPayload(v); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - } - break; - case tokenFalse: - { - Value v(false); - currentValue().swapPayload(v); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - } - break; - case tokenNull: - { - Value v; - currentValue().swapPayload(v); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - } - break; - case tokenArraySeparator: - case tokenObjectEnd: - case tokenArrayEnd: - if (features_.allowDroppedNullPlaceholders_) { - // "Un-read" the current token and mark the current value as a null - // token. - current_--; - Value v; - currentValue().swapPayload(v); - currentValue().setOffsetStart(current_ - begin_ - 1); - currentValue().setOffsetLimit(current_ - begin_); - break; - } // else, fall through ... - default: - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - return addError("Syntax error: value, object or array expected.", token); - } - - if (collectComments_) { - lastValueEnd_ = current_; - lastValue_ = ¤tValue(); - } - - --stackDepth_; - return successful; -} - -void OurReader::skipCommentTokens(Token& token) { - if (features_.allowComments_) { - do { - readToken(token); - } while (token.type_ == tokenComment); - } else { - readToken(token); - } -} - -bool OurReader::readToken(Token& token) { - skipSpaces(); - token.start_ = current_; - Char c = getNextChar(); - bool ok = true; - switch (c) { - case '{': - token.type_ = tokenObjectBegin; - break; - case '}': - token.type_ = tokenObjectEnd; - break; - case '[': - token.type_ = tokenArrayBegin; - break; - case ']': - token.type_ = tokenArrayEnd; - break; - case '"': - token.type_ = tokenString; - ok = readString(); - break; - case '\'': - if (features_.allowSingleQuotes_) { - token.type_ = tokenString; - ok = readStringSingleQuote(); - break; - } // else continue - case '/': - token.type_ = tokenComment; - ok = readComment(); - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - case '-': - token.type_ = tokenNumber; - readNumber(); - break; - case 't': - token.type_ = tokenTrue; - ok = match("rue", 3); - break; - case 'f': - token.type_ = tokenFalse; - ok = match("alse", 4); - break; - case 'n': - token.type_ = tokenNull; - ok = match("ull", 3); - break; - case ',': - token.type_ = tokenArraySeparator; - break; - case ':': - token.type_ = tokenMemberSeparator; - break; - case 0: - token.type_ = tokenEndOfStream; - break; - default: - ok = false; - break; - } - if (!ok) - token.type_ = tokenError; - token.end_ = current_; - return true; -} - -void OurReader::skipSpaces() { - while (current_ != end_) { - Char c = *current_; - if (c == ' ' || c == '\t' || c == '\r' || c == '\n') - ++current_; - else - break; - } -} - -bool OurReader::match(Location pattern, int patternLength) { - if (end_ - current_ < patternLength) - return false; - int index = patternLength; - while (index--) - if (current_[index] != pattern[index]) - return false; - current_ += patternLength; - return true; -} - -bool OurReader::readComment() { - Location commentBegin = current_ - 1; - Char c = getNextChar(); - bool successful = false; - if (c == '*') - successful = readCStyleComment(); - else if (c == '/') - successful = readCppStyleComment(); - if (!successful) - return false; - - if (collectComments_) { - CommentPlacement placement = commentBefore; - if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) { - if (c != '*' || !containsNewLine(commentBegin, current_)) - placement = commentAfterOnSameLine; - } - - addComment(commentBegin, current_, placement); - } - return true; -} - -void -OurReader::addComment(Location begin, Location end, CommentPlacement placement) { - assert(collectComments_); - const std::string& normalized = normalizeEOL(begin, end); - if (placement == commentAfterOnSameLine) { - assert(lastValue_ != 0); - lastValue_->setComment(normalized, placement); - } else { - commentsBefore_ += normalized; - } -} - -bool OurReader::readCStyleComment() { - while (current_ != end_) { - Char c = getNextChar(); - if (c == '*' && *current_ == '/') - break; - } - return getNextChar() == '/'; -} - -bool OurReader::readCppStyleComment() { - while (current_ != end_) { - Char c = getNextChar(); - if (c == '\n') - break; - if (c == '\r') { - // Consume DOS EOL. It will be normalized in addComment. - if (current_ != end_ && *current_ == '\n') - getNextChar(); - // Break on Moc OS 9 EOL. - break; - } - } - return true; -} - -void OurReader::readNumber() { - const char *p = current_; - char c = '0'; // stopgap for already consumed character - // integral part - while (c >= '0' && c <= '9') - c = (current_ = p) < end_ ? *p++ : 0; - // fractional part - if (c == '.') { - c = (current_ = p) < end_ ? *p++ : 0; - while (c >= '0' && c <= '9') - c = (current_ = p) < end_ ? *p++ : 0; - } - // exponential part - if (c == 'e' || c == 'E') { - c = (current_ = p) < end_ ? *p++ : 0; - if (c == '+' || c == '-') - c = (current_ = p) < end_ ? *p++ : 0; - while (c >= '0' && c <= '9') - c = (current_ = p) < end_ ? *p++ : 0; - } -} -bool OurReader::readString() { - Char c = 0; - while (current_ != end_) { - c = getNextChar(); - if (c == '\\') - getNextChar(); - else if (c == '"') - break; - } - return c == '"'; -} - - -bool OurReader::readStringSingleQuote() { - Char c = 0; - while (current_ != end_) { - c = getNextChar(); - if (c == '\\') - getNextChar(); - else if (c == '\'') - break; - } - return c == '\''; -} - -bool OurReader::readObject(Token& tokenStart) { - Token tokenName; - std::string name; - Value init(objectValue); - currentValue().swapPayload(init); - currentValue().setOffsetStart(tokenStart.start_ - begin_); - while (readToken(tokenName)) { - bool initialTokenOk = true; - while (tokenName.type_ == tokenComment && initialTokenOk) - initialTokenOk = readToken(tokenName); - if (!initialTokenOk) - break; - if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object - return true; - name = ""; - if (tokenName.type_ == tokenString) { - if (!decodeString(tokenName, name)) - return recoverFromError(tokenObjectEnd); - } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) { - Value numberName; - if (!decodeNumber(tokenName, numberName)) - return recoverFromError(tokenObjectEnd); - name = numberName.asString(); - } else { - break; - } - - Token colon; - if (!readToken(colon) || colon.type_ != tokenMemberSeparator) { - return addErrorAndRecover( - "Missing ':' after object member name", colon, tokenObjectEnd); - } - if (name.length() >= (1U<<30)) throwRuntimeError("keylength >= 2^30"); - if (features_.rejectDupKeys_ && currentValue().isMember(name)) { - std::string msg = "Duplicate key: '" + name + "'"; - return addErrorAndRecover( - msg, tokenName, tokenObjectEnd); - } - Value& value = currentValue()[name]; - nodes_.push(&value); - bool ok = readValue(); - nodes_.pop(); - if (!ok) // error already set - return recoverFromError(tokenObjectEnd); - - Token comma; - if (!readToken(comma) || - (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator && - comma.type_ != tokenComment)) { - return addErrorAndRecover( - "Missing ',' or '}' in object declaration", comma, tokenObjectEnd); - } - bool finalizeTokenOk = true; - while (comma.type_ == tokenComment && finalizeTokenOk) - finalizeTokenOk = readToken(comma); - if (comma.type_ == tokenObjectEnd) - return true; - } - return addErrorAndRecover( - "Missing '}' or object member name", tokenName, tokenObjectEnd); -} - -bool OurReader::readArray(Token& tokenStart) { - Value init(arrayValue); - currentValue().swapPayload(init); - currentValue().setOffsetStart(tokenStart.start_ - begin_); - skipSpaces(); - if (*current_ == ']') // empty array - { - Token endArray; - readToken(endArray); - return true; - } - int index = 0; - for (;;) { - Value& value = currentValue()[index++]; - nodes_.push(&value); - bool ok = readValue(); - nodes_.pop(); - if (!ok) // error already set - return recoverFromError(tokenArrayEnd); - - Token token; - // Accept Comment after last item in the array. - ok = readToken(token); - while (token.type_ == tokenComment && ok) { - ok = readToken(token); - } - bool badTokenType = - (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd); - if (!ok || badTokenType) { - return addErrorAndRecover( - "Missing ',' or ']' in array declaration", token, tokenArrayEnd); - } - if (token.type_ == tokenArrayEnd) - break; - } - return true; -} - -bool OurReader::decodeNumber(Token& token) { - Value decoded; - if (!decodeNumber(token, decoded)) - return false; - currentValue().swapPayload(decoded); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - return true; -} - -bool OurReader::decodeNumber(Token& token, Value& decoded) { - // Attempts to parse the number as an integer. If the number is - // larger than the maximum supported value of an integer then - // we decode the number as a double. - Location current = token.start_; - bool isNegative = *current == '-'; - if (isNegative) - ++current; - // TODO: Help the compiler do the div and mod at compile time or get rid of them. - Value::LargestUInt maxIntegerValue = - isNegative ? Value::LargestUInt(-Value::minLargestInt) - : Value::maxLargestUInt; - Value::LargestUInt threshold = maxIntegerValue / 10; - Value::LargestUInt value = 0; - while (current < token.end_) { - Char c = *current++; - if (c < '0' || c > '9') - return decodeDouble(token, decoded); - Value::UInt digit(c - '0'); - if (value >= threshold) { - // We've hit or exceeded the max value divided by 10 (rounded down). If - // a) we've only just touched the limit, b) this is the last digit, and - // c) it's small enough to fit in that rounding delta, we're okay. - // Otherwise treat this number as a double to avoid overflow. - if (value > threshold || current != token.end_ || - digit > maxIntegerValue % 10) { - return decodeDouble(token, decoded); - } - } - value = value * 10 + digit; - } - if (isNegative) - decoded = -Value::LargestInt(value); - else if (value <= Value::LargestUInt(Value::maxInt)) - decoded = Value::LargestInt(value); - else - decoded = value; - return true; -} - -bool OurReader::decodeDouble(Token& token) { - Value decoded; - if (!decodeDouble(token, decoded)) - return false; - currentValue().swapPayload(decoded); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - return true; -} - -bool OurReader::decodeDouble(Token& token, Value& decoded) { - double value = 0; - const int bufferSize = 32; - int count; - int length = int(token.end_ - token.start_); - - // Sanity check to avoid buffer overflow exploits. - if (length < 0) { - return addError("Unable to parse token length", token); - } - - // Avoid using a string constant for the format control string given to - // sscanf, as this can cause hard to debug crashes on OS X. See here for more - // info: - // - // http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html - char format[] = "%lf"; - - if (length <= bufferSize) { - Char buffer[bufferSize + 1]; - memcpy(buffer, token.start_, length); - buffer[length] = 0; - count = sscanf(buffer, format, &value); - } else { - std::string buffer(token.start_, token.end_); - count = sscanf(buffer.c_str(), format, &value); - } - - if (count != 1) - return addError("'" + std::string(token.start_, token.end_) + - "' is not a number.", - token); - decoded = value; - return true; -} - -bool OurReader::decodeString(Token& token) { - std::string decoded_string; - if (!decodeString(token, decoded_string)) - return false; - Value decoded(decoded_string); - currentValue().swapPayload(decoded); - currentValue().setOffsetStart(token.start_ - begin_); - currentValue().setOffsetLimit(token.end_ - begin_); - return true; -} - -bool OurReader::decodeString(Token& token, std::string& decoded) { - decoded.reserve(token.end_ - token.start_ - 2); - Location current = token.start_ + 1; // skip '"' - Location end = token.end_ - 1; // do not include '"' - while (current != end) { - Char c = *current++; - if (c == '"') - break; - else if (c == '\\') { - if (current == end) - return addError("Empty escape sequence in string", token, current); - Char escape = *current++; - switch (escape) { - case '"': - decoded += '"'; - break; - case '/': - decoded += '/'; - break; - case '\\': - decoded += '\\'; - break; - case 'b': - decoded += '\b'; - break; - case 'f': - decoded += '\f'; - break; - case 'n': - decoded += '\n'; - break; - case 'r': - decoded += '\r'; - break; - case 't': - decoded += '\t'; - break; - case 'u': { - unsigned int unicode; - if (!decodeUnicodeCodePoint(token, current, end, unicode)) - return false; - decoded += codePointToUTF8(unicode); - } break; - default: - return addError("Bad escape sequence in string", token, current); - } - } else { - decoded += c; - } - } - return true; -} - -bool OurReader::decodeUnicodeCodePoint(Token& token, - Location& current, - Location end, - unsigned int& unicode) { - - if (!decodeUnicodeEscapeSequence(token, current, end, unicode)) - return false; - if (unicode >= 0xD800 && unicode <= 0xDBFF) { - // surrogate pairs - if (end - current < 6) - return addError( - "additional six characters expected to parse unicode surrogate pair.", - token, - current); - unsigned int surrogatePair; - if (*(current++) == '\\' && *(current++) == 'u') { - if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) { - unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF); - } else - return false; - } else - return addError("expecting another \\u token to begin the second half of " - "a unicode surrogate pair", - token, - current); - } - return true; -} - -bool OurReader::decodeUnicodeEscapeSequence(Token& token, - Location& current, - Location end, - unsigned int& unicode) { - if (end - current < 4) - return addError( - "Bad unicode escape sequence in string: four digits expected.", - token, - current); - unicode = 0; - for (int index = 0; index < 4; ++index) { - Char c = *current++; - unicode *= 16; - if (c >= '0' && c <= '9') - unicode += c - '0'; - else if (c >= 'a' && c <= 'f') - unicode += c - 'a' + 10; - else if (c >= 'A' && c <= 'F') - unicode += c - 'A' + 10; - else - return addError( - "Bad unicode escape sequence in string: hexadecimal digit expected.", - token, - current); - } - return true; -} - -bool -OurReader::addError(const std::string& message, Token& token, Location extra) { - ErrorInfo info; - info.token_ = token; - info.message_ = message; - info.extra_ = extra; - errors_.push_back(info); - return false; -} - -bool OurReader::recoverFromError(TokenType skipUntilToken) { - int errorCount = int(errors_.size()); - Token skip; - for (;;) { - if (!readToken(skip)) - errors_.resize(errorCount); // discard errors caused by recovery - if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream) - break; - } - errors_.resize(errorCount); - return false; -} - -bool OurReader::addErrorAndRecover(const std::string& message, - Token& token, - TokenType skipUntilToken) { - addError(message, token); - return recoverFromError(skipUntilToken); -} - -Value& OurReader::currentValue() { return *(nodes_.top()); } - -OurReader::Char OurReader::getNextChar() { - if (current_ == end_) - return 0; - return *current_++; -} - -void OurReader::getLocationLineAndColumn(Location location, - int& line, - int& column) const { - Location current = begin_; - Location lastLineStart = current; - line = 0; - while (current < location && current != end_) { - Char c = *current++; - if (c == '\r') { - if (*current == '\n') - ++current; - lastLineStart = current; - ++line; - } else if (c == '\n') { - lastLineStart = current; - ++line; - } - } - // column & line start at 1 - column = int(location - lastLineStart) + 1; - ++line; -} - -std::string OurReader::getLocationLineAndColumn(Location location) const { - int line, column; - getLocationLineAndColumn(location, line, column); - char buffer[18 + 16 + 16 + 1]; -#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) -#if defined(WINCE) - _snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column); -#else - sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column); -#endif -#else - snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column); -#endif - return buffer; -} - -std::string OurReader::getFormattedErrorMessages() const { - std::string formattedMessage; - for (Errors::const_iterator itError = errors_.begin(); - itError != errors_.end(); - ++itError) { - const ErrorInfo& error = *itError; - formattedMessage += - "* " + getLocationLineAndColumn(error.token_.start_) + "\n"; - formattedMessage += " " + error.message_ + "\n"; - if (error.extra_) - formattedMessage += - "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n"; - } - return formattedMessage; -} - -std::vector OurReader::getStructuredErrors() const { - std::vector allErrors; - for (Errors::const_iterator itError = errors_.begin(); - itError != errors_.end(); - ++itError) { - const ErrorInfo& error = *itError; - OurReader::StructuredError structured; - structured.offset_start = error.token_.start_ - begin_; - structured.offset_limit = error.token_.end_ - begin_; - structured.message = error.message_; - allErrors.push_back(structured); - } - return allErrors; -} - -bool OurReader::pushError(const Value& value, const std::string& message) { - size_t length = end_ - begin_; - if(value.getOffsetStart() > length - || value.getOffsetLimit() > length) - return false; - Token token; - token.type_ = tokenError; - token.start_ = begin_ + value.getOffsetStart(); - token.end_ = end_ + value.getOffsetLimit(); - ErrorInfo info; - info.token_ = token; - info.message_ = message; - info.extra_ = 0; - errors_.push_back(info); - return true; -} - -bool OurReader::pushError(const Value& value, const std::string& message, const Value& extra) { - size_t length = end_ - begin_; - if(value.getOffsetStart() > length - || value.getOffsetLimit() > length - || extra.getOffsetLimit() > length) - return false; - Token token; - token.type_ = tokenError; - token.start_ = begin_ + value.getOffsetStart(); - token.end_ = begin_ + value.getOffsetLimit(); - ErrorInfo info; - info.token_ = token; - info.message_ = message; - info.extra_ = begin_ + extra.getOffsetStart(); - errors_.push_back(info); - return true; -} - -bool OurReader::good() const { - return !errors_.size(); -} - - -class OurCharReader : public CharReader { - bool const collectComments_; - OurReader reader_; -public: - OurCharReader( - bool collectComments, - OurFeatures const& features) - : collectComments_(collectComments) - , reader_(features) - {} - virtual bool parse( - char const* beginDoc, char const* endDoc, - Value* root, std::string* errs) { - bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_); - if (errs) { - *errs = reader_.getFormattedErrorMessages(); - } - return ok; - } -}; - -CharReaderBuilder::CharReaderBuilder() -{ - setDefaults(&settings_); -} -CharReaderBuilder::~CharReaderBuilder() -{} -CharReader* CharReaderBuilder::newCharReader() const -{ - bool collectComments = settings_["collectComments"].asBool(); - OurFeatures features = OurFeatures::all(); - features.allowComments_ = settings_["allowComments"].asBool(); - features.strictRoot_ = settings_["strictRoot"].asBool(); - features.allowDroppedNullPlaceholders_ = settings_["allowDroppedNullPlaceholders"].asBool(); - features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool(); - features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool(); - features.stackLimit_ = settings_["stackLimit"].asInt(); - features.failIfExtra_ = settings_["failIfExtra"].asBool(); - features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool(); - return new OurCharReader(collectComments, features); -} -static void getValidReaderKeys(std::set* valid_keys) -{ - valid_keys->clear(); - valid_keys->insert("collectComments"); - valid_keys->insert("allowComments"); - valid_keys->insert("strictRoot"); - valid_keys->insert("allowDroppedNullPlaceholders"); - valid_keys->insert("allowNumericKeys"); - valid_keys->insert("allowSingleQuotes"); - valid_keys->insert("stackLimit"); - valid_keys->insert("failIfExtra"); - valid_keys->insert("rejectDupKeys"); -} -bool CharReaderBuilder::validate(Json::Value* invalid) const -{ - Json::Value my_invalid; - if (!invalid) invalid = &my_invalid; // so we do not need to test for NULL - Json::Value& inv = *invalid; - std::set valid_keys; - getValidReaderKeys(&valid_keys); - Value::Members keys = settings_.getMemberNames(); - size_t n = keys.size(); - for (size_t i = 0; i < n; ++i) { - std::string const& key = keys[i]; - if (valid_keys.find(key) == valid_keys.end()) { - inv[key] = settings_[key]; - } - } - return 0u == inv.size(); -} -Value& CharReaderBuilder::operator[](std::string key) -{ - return settings_[key]; -} -// static -void CharReaderBuilder::strictMode(Json::Value* settings) -{ -//! [CharReaderBuilderStrictMode] - (*settings)["allowComments"] = false; - (*settings)["strictRoot"] = true; - (*settings)["allowDroppedNullPlaceholders"] = false; - (*settings)["allowNumericKeys"] = false; - (*settings)["allowSingleQuotes"] = false; - (*settings)["failIfExtra"] = true; - (*settings)["rejectDupKeys"] = true; -//! [CharReaderBuilderStrictMode] -} -// static -void CharReaderBuilder::setDefaults(Json::Value* settings) -{ -//! [CharReaderBuilderDefaults] - (*settings)["collectComments"] = true; - (*settings)["allowComments"] = true; - (*settings)["strictRoot"] = false; - (*settings)["allowDroppedNullPlaceholders"] = false; - (*settings)["allowNumericKeys"] = false; - (*settings)["allowSingleQuotes"] = false; - (*settings)["stackLimit"] = 1000; - (*settings)["failIfExtra"] = false; - (*settings)["rejectDupKeys"] = false; -//! [CharReaderBuilderDefaults] -} - -////////////////////////////////// -// global functions - -bool parseFromStream( - CharReader::Factory const& fact, std::istream& sin, - Value* root, std::string* errs) -{ - std::ostringstream ssin; - ssin << sin.rdbuf(); - std::string doc = ssin.str(); - char const* begin = doc.data(); - char const* end = begin + doc.size(); - // Note that we do not actually need a null-terminator. - CharReaderPtr const reader(fact.newCharReader()); - return reader->parse(begin, end, root, errs); -} - -std::istream& operator>>(std::istream& sin, Value& root) { - CharReaderBuilder b; - std::string errs; - bool ok = parseFromStream(b, sin, &root, &errs); - if (!ok) { - fprintf(stderr, - "Error from reader: %s", - errs.c_str()); - - throwRuntimeError("reader error"); - } - return sin; -} - -} // namespace Json - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: src/lib_json/json_reader.cpp -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: src/lib_json/json_valueiterator.inl -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -// included by json_value.cpp - -namespace Json { - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class ValueIteratorBase -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -ValueIteratorBase::ValueIteratorBase() - : current_(), isNull_(true) { -} - -ValueIteratorBase::ValueIteratorBase( - const Value::ObjectValues::iterator& current) - : current_(current), isNull_(false) {} - -Value& ValueIteratorBase::deref() const { - return current_->second; -} - -void ValueIteratorBase::increment() { - ++current_; -} - -void ValueIteratorBase::decrement() { - --current_; -} - -ValueIteratorBase::difference_type -ValueIteratorBase::computeDistance(const SelfType& other) const { -#ifdef JSON_USE_CPPTL_SMALLMAP - return other.current_ - current_; -#else - // Iterator for null value are initialized using the default - // constructor, which initialize current_ to the default - // std::map::iterator. As begin() and end() are two instance - // of the default std::map::iterator, they can not be compared. - // To allow this, we handle this comparison specifically. - if (isNull_ && other.isNull_) { - return 0; - } - - // Usage of std::distance is not portable (does not compile with Sun Studio 12 - // RogueWave STL, - // which is the one used by default). - // Using a portable hand-made version for non random iterator instead: - // return difference_type( std::distance( current_, other.current_ ) ); - difference_type myDistance = 0; - for (Value::ObjectValues::iterator it = current_; it != other.current_; - ++it) { - ++myDistance; - } - return myDistance; -#endif -} - -bool ValueIteratorBase::isEqual(const SelfType& other) const { - if (isNull_) { - return other.isNull_; - } - return current_ == other.current_; -} - -void ValueIteratorBase::copy(const SelfType& other) { - current_ = other.current_; - isNull_ = other.isNull_; -} - -Value ValueIteratorBase::key() const { - const Value::CZString czstring = (*current_).first; - if (czstring.data()) { - if (czstring.isStaticString()) - return Value(StaticString(czstring.data())); - return Value(czstring.data(), czstring.data() + czstring.length()); - } - return Value(czstring.index()); -} - -UInt ValueIteratorBase::index() const { - const Value::CZString czstring = (*current_).first; - if (!czstring.data()) - return czstring.index(); - return Value::UInt(-1); -} - -std::string ValueIteratorBase::name() const { - char const* keey; - char const* end; - keey = memberName(&end); - if (!keey) return std::string(); - return std::string(keey, end); -} - -char const* ValueIteratorBase::memberName() const { - const char* cname = (*current_).first.data(); - return cname ? cname : ""; -} - -char const* ValueIteratorBase::memberName(char const** end) const { - const char* cname = (*current_).first.data(); - if (!cname) { - *end = NULL; - return NULL; - } - *end = cname + (*current_).first.length(); - return cname; -} - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class ValueConstIterator -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -ValueConstIterator::ValueConstIterator() {} - -ValueConstIterator::ValueConstIterator( - const Value::ObjectValues::iterator& current) - : ValueIteratorBase(current) {} - -ValueConstIterator& ValueConstIterator:: -operator=(const ValueIteratorBase& other) { - copy(other); - return *this; -} - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class ValueIterator -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -ValueIterator::ValueIterator() {} - -ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current) - : ValueIteratorBase(current) {} - -ValueIterator::ValueIterator(const ValueConstIterator& other) - : ValueIteratorBase(other) {} - -ValueIterator::ValueIterator(const ValueIterator& other) - : ValueIteratorBase(other) {} - -ValueIterator& ValueIterator::operator=(const SelfType& other) { - copy(other); - return *this; -} - -} // namespace Json - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: src/lib_json/json_valueiterator.inl -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: src/lib_json/json_value.cpp -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2011 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#if !defined(JSON_IS_AMALGAMATION) -#include -#include -#include -#endif // if !defined(JSON_IS_AMALGAMATION) -#include -#include -#include -#include -#include -#ifdef JSON_USE_CPPTL -#include -#endif -#include // size_t -#include // min() - -#define JSON_ASSERT_UNREACHABLE assert(false) - -namespace Json { - -// This is a walkaround to avoid the static initialization of Value::null. -// kNull must be word-aligned to avoid crashing on ARM. We use an alignment of -// 8 (instead of 4) as a bit of future-proofing. -#if defined(__ARMEL__) -#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment))) -#else -#define ALIGNAS(byte_alignment) -#endif -static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 }; -const unsigned char& kNullRef = kNull[0]; -const Value& Value::null = reinterpret_cast(kNullRef); -const Value& Value::nullRef = null; - -const Int Value::minInt = Int(~(UInt(-1) / 2)); -const Int Value::maxInt = Int(UInt(-1) / 2); -const UInt Value::maxUInt = UInt(-1); -#if defined(JSON_HAS_INT64) -const Int64 Value::minInt64 = Int64(~(UInt64(-1) / 2)); -const Int64 Value::maxInt64 = Int64(UInt64(-1) / 2); -const UInt64 Value::maxUInt64 = UInt64(-1); -// The constant is hard-coded because some compiler have trouble -// converting Value::maxUInt64 to a double correctly (AIX/xlC). -// Assumes that UInt64 is a 64 bits integer. -static const double maxUInt64AsDouble = 18446744073709551615.0; -#endif // defined(JSON_HAS_INT64) -const LargestInt Value::minLargestInt = LargestInt(~(LargestUInt(-1) / 2)); -const LargestInt Value::maxLargestInt = LargestInt(LargestUInt(-1) / 2); -const LargestUInt Value::maxLargestUInt = LargestUInt(-1); - -#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) -template -static inline bool InRange(double d, T min, U max) { - return d >= min && d <= max; -} -#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) -static inline double integerToDouble(Json::UInt64 value) { - return static_cast(Int64(value / 2)) * 2.0 + Int64(value & 1); -} - -template static inline double integerToDouble(T value) { - return static_cast(value); -} - -template -static inline bool InRange(double d, T min, U max) { - return d >= integerToDouble(min) && d <= integerToDouble(max); -} -#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) - -/** Duplicates the specified string value. - * @param value Pointer to the string to duplicate. Must be zero-terminated if - * length is "unknown". - * @param length Length of the value. if equals to unknown, then it will be - * computed using strlen(value). - * @return Pointer on the duplicate instance of string. - */ -static inline char* duplicateStringValue(const char* value, - size_t length) { - // Avoid an integer overflow in the call to malloc below by limiting length - // to a sane value. - if (length >= (size_t)Value::maxInt) - length = Value::maxInt - 1; - - char* newString = static_cast(malloc(length + 1)); - if (newString == NULL) { - throwRuntimeError( - "in Json::Value::duplicateStringValue(): " - "Failed to allocate string value buffer"); - } - memcpy(newString, value, length); - newString[length] = 0; - return newString; -} - -/* Record the length as a prefix. - */ -static inline char* duplicateAndPrefixStringValue( - const char* value, - unsigned int length) -{ - // Avoid an integer overflow in the call to malloc below by limiting length - // to a sane value. - JSON_ASSERT_MESSAGE(length <= (unsigned)Value::maxInt - sizeof(unsigned) - 1U, - "in Json::Value::duplicateAndPrefixStringValue(): " - "length too big for prefixing"); - unsigned actualLength = length + static_cast(sizeof(unsigned)) + 1U; - char* newString = static_cast(malloc(actualLength)); - if (newString == 0) { - throwRuntimeError( - "in Json::Value::duplicateAndPrefixStringValue(): " - "Failed to allocate string value buffer"); - } - *reinterpret_cast(newString) = length; - memcpy(newString + sizeof(unsigned), value, length); - newString[actualLength - 1U] = 0; // to avoid buffer over-run accidents by users later - return newString; -} -inline static void decodePrefixedString( - bool isPrefixed, char const* prefixed, - unsigned* length, char const** value) -{ - if (!isPrefixed) { - *length = static_cast(strlen(prefixed)); - *value = prefixed; - } else { - *length = *reinterpret_cast(prefixed); - *value = prefixed + sizeof(unsigned); - } -} -/** Free the string duplicated by duplicateStringValue()/duplicateAndPrefixStringValue(). - */ -static inline void releaseStringValue(char* value) { free(value); } - -} // namespace Json - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ValueInternals... -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -#if !defined(JSON_IS_AMALGAMATION) - -#include "json_valueiterator.inl" -#endif // if !defined(JSON_IS_AMALGAMATION) - -namespace Json { - -Exception::Exception(std::string const& msg) - : msg_(msg) -{} -Exception::~Exception() throw() -{} -char const* Exception::what() const throw() -{ - return msg_.c_str(); -} -RuntimeError::RuntimeError(std::string const& msg) - : Exception(msg) -{} -LogicError::LogicError(std::string const& msg) - : Exception(msg) -{} -void throwRuntimeError(std::string const& msg) -{ - throw RuntimeError(msg); -} -void throwLogicError(std::string const& msg) -{ - throw LogicError(msg); -} - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class Value::CommentInfo -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -Value::CommentInfo::CommentInfo() : comment_(0) {} - -Value::CommentInfo::~CommentInfo() { - if (comment_) - releaseStringValue(comment_); -} - -void Value::CommentInfo::setComment(const char* text, size_t len) { - if (comment_) { - releaseStringValue(comment_); - comment_ = 0; - } - JSON_ASSERT(text != 0); - JSON_ASSERT_MESSAGE( - text[0] == '\0' || text[0] == '/', - "in Json::Value::setComment(): Comments must start with /"); - // It seems that /**/ style comments are acceptable as well. - comment_ = duplicateStringValue(text, len); -} - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class Value::CZString -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -// Notes: policy_ indicates if the string was allocated when -// a string is stored. - -Value::CZString::CZString(ArrayIndex aindex) : cstr_(0), index_(aindex) {} - -Value::CZString::CZString(char const* str, unsigned ulength, DuplicationPolicy allocate) - : cstr_(str) -{ - // allocate != duplicate - storage_.policy_ = allocate & 0x3; - storage_.length_ = ulength & 0x3FFFFFFF; -} - -Value::CZString::CZString(const CZString& other) - : cstr_(other.storage_.policy_ != noDuplication && other.cstr_ != 0 - ? duplicateStringValue(other.cstr_, other.storage_.length_) - : other.cstr_) -{ - storage_.policy_ = (other.cstr_ - ? (static_cast(other.storage_.policy_) == noDuplication - ? noDuplication : duplicate) - : static_cast(other.storage_.policy_)); - storage_.length_ = other.storage_.length_; -} - -Value::CZString::~CZString() { - if (cstr_ && storage_.policy_ == duplicate) - releaseStringValue(const_cast(cstr_)); -} - -void Value::CZString::swap(CZString& other) { - std::swap(cstr_, other.cstr_); - std::swap(index_, other.index_); -} - -Value::CZString& Value::CZString::operator=(CZString other) { - swap(other); - return *this; -} - -bool Value::CZString::operator<(const CZString& other) const { - if (!cstr_) return index_ < other.index_; - //return strcmp(cstr_, other.cstr_) < 0; - // Assume both are strings. - unsigned this_len = this->storage_.length_; - unsigned other_len = other.storage_.length_; - unsigned min_len = std::min(this_len, other_len); - int comp = memcmp(this->cstr_, other.cstr_, min_len); - if (comp < 0) return true; - if (comp > 0) return false; - return (this_len < other_len); -} - -bool Value::CZString::operator==(const CZString& other) const { - if (!cstr_) return index_ == other.index_; - //return strcmp(cstr_, other.cstr_) == 0; - // Assume both are strings. - unsigned this_len = this->storage_.length_; - unsigned other_len = other.storage_.length_; - if (this_len != other_len) return false; - int comp = memcmp(this->cstr_, other.cstr_, this_len); - return comp == 0; -} - -ArrayIndex Value::CZString::index() const { return index_; } - -//const char* Value::CZString::c_str() const { return cstr_; } -const char* Value::CZString::data() const { return cstr_; } -unsigned Value::CZString::length() const { return storage_.length_; } -bool Value::CZString::isStaticString() const { return storage_.policy_ == noDuplication; } - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class Value::Value -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -/*! \internal Default constructor initialization must be equivalent to: - * memset( this, 0, sizeof(Value) ) - * This optimization is used in ValueInternalMap fast allocator. - */ -Value::Value(ValueType vtype) { - initBasic(vtype); - switch (vtype) { - case nullValue: - break; - case intValue: - case uintValue: - value_.int_ = 0; - break; - case realValue: - value_.real_ = 0.0; - break; - case stringValue: - value_.string_ = 0; - break; - case arrayValue: - case objectValue: - value_.map_ = new ObjectValues(); - break; - case booleanValue: - value_.bool_ = false; - break; - default: - JSON_ASSERT_UNREACHABLE; - } -} - -Value::Value(Int value) { - initBasic(intValue); - value_.int_ = value; -} - -Value::Value(UInt value) { - initBasic(uintValue); - value_.uint_ = value; -} -#if defined(JSON_HAS_INT64) -Value::Value(Int64 value) { - initBasic(intValue); - value_.int_ = value; -} -Value::Value(UInt64 value) { - initBasic(uintValue); - value_.uint_ = value; -} -#endif // defined(JSON_HAS_INT64) - -Value::Value(double value) { - initBasic(realValue); - value_.real_ = value; -} - -Value::Value(const char* value) { - initBasic(stringValue, true); - value_.string_ = duplicateAndPrefixStringValue(value, static_cast(strlen(value))); -} - -Value::Value(const char* beginValue, const char* endValue) { - initBasic(stringValue, true); - value_.string_ = - duplicateAndPrefixStringValue(beginValue, static_cast(endValue - beginValue)); -} - -Value::Value(const std::string& value) { - initBasic(stringValue, true); - value_.string_ = - duplicateAndPrefixStringValue(value.data(), static_cast(value.length())); -} - -Value::Value(const StaticString& value) { - initBasic(stringValue); - value_.string_ = const_cast(value.c_str()); -} - -#ifdef JSON_USE_CPPTL -Value::Value(const CppTL::ConstString& value) { - initBasic(stringValue, true); - value_.string_ = duplicateAndPrefixStringValue(value, static_cast(value.length())); -} -#endif - -Value::Value(bool value) { - initBasic(booleanValue); - value_.bool_ = value; -} - -Value::Value(Value const& other) - : type_(other.type_), allocated_(false) - , - comments_(0), start_(other.start_), limit_(other.limit_) -{ - switch (type_) { - case nullValue: - case intValue: - case uintValue: - case realValue: - case booleanValue: - value_ = other.value_; - break; - case stringValue: - if (other.value_.string_ && other.allocated_) { - unsigned len; - char const* str; - decodePrefixedString(other.allocated_, other.value_.string_, - &len, &str); - value_.string_ = duplicateAndPrefixStringValue(str, len); - allocated_ = true; - } else { - value_.string_ = other.value_.string_; - allocated_ = false; - } - break; - case arrayValue: - case objectValue: - value_.map_ = new ObjectValues(*other.value_.map_); - break; - default: - JSON_ASSERT_UNREACHABLE; - } - if (other.comments_) { - comments_ = new CommentInfo[numberOfCommentPlacement]; - for (int comment = 0; comment < numberOfCommentPlacement; ++comment) { - const CommentInfo& otherComment = other.comments_[comment]; - if (otherComment.comment_) - comments_[comment].setComment( - otherComment.comment_, strlen(otherComment.comment_)); - } - } -} - -Value::~Value() { - switch (type_) { - case nullValue: - case intValue: - case uintValue: - case realValue: - case booleanValue: - break; - case stringValue: - if (allocated_) - releaseStringValue(value_.string_); - break; - case arrayValue: - case objectValue: - delete value_.map_; - break; - default: - JSON_ASSERT_UNREACHABLE; - } - - if (comments_) - delete[] comments_; -} - -Value& Value::operator=(Value other) { - swap(other); - return *this; -} - -void Value::swapPayload(Value& other) { - ValueType temp = type_; - type_ = other.type_; - other.type_ = temp; - std::swap(value_, other.value_); - int temp2 = allocated_; - allocated_ = other.allocated_; - other.allocated_ = temp2 & 0x1; -} - -void Value::swap(Value& other) { - swapPayload(other); - std::swap(comments_, other.comments_); - std::swap(start_, other.start_); - std::swap(limit_, other.limit_); -} - -ValueType Value::type() const { return type_; } - -int Value::compare(const Value& other) const { - if (*this < other) - return -1; - if (*this > other) - return 1; - return 0; -} - -bool Value::operator<(const Value& other) const { - int typeDelta = type_ - other.type_; - if (typeDelta) - return typeDelta < 0 ? true : false; - switch (type_) { - case nullValue: - return false; - case intValue: - return value_.int_ < other.value_.int_; - case uintValue: - return value_.uint_ < other.value_.uint_; - case realValue: - return value_.real_ < other.value_.real_; - case booleanValue: - return value_.bool_ < other.value_.bool_; - case stringValue: - { - if ((value_.string_ == 0) || (other.value_.string_ == 0)) { - if (other.value_.string_) return true; - else return false; - } - unsigned this_len; - unsigned other_len; - char const* this_str; - char const* other_str; - decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str); - decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str); - unsigned min_len = std::min(this_len, other_len); - int comp = memcmp(this_str, other_str, min_len); - if (comp < 0) return true; - if (comp > 0) return false; - return (this_len < other_len); - } - case arrayValue: - case objectValue: { - int delta = int(value_.map_->size() - other.value_.map_->size()); - if (delta) - return delta < 0; - return (*value_.map_) < (*other.value_.map_); - } - default: - JSON_ASSERT_UNREACHABLE; - } - return false; // unreachable -} - -bool Value::operator<=(const Value& other) const { return !(other < *this); } - -bool Value::operator>=(const Value& other) const { return !(*this < other); } - -bool Value::operator>(const Value& other) const { return other < *this; } - -bool Value::operator==(const Value& other) const { - // if ( type_ != other.type_ ) - // GCC 2.95.3 says: - // attempt to take address of bit-field structure member `Json::Value::type_' - // Beats me, but a temp solves the problem. - int temp = other.type_; - if (type_ != temp) - return false; - switch (type_) { - case nullValue: - return true; - case intValue: - return value_.int_ == other.value_.int_; - case uintValue: - return value_.uint_ == other.value_.uint_; - case realValue: - return value_.real_ == other.value_.real_; - case booleanValue: - return value_.bool_ == other.value_.bool_; - case stringValue: - { - if ((value_.string_ == 0) || (other.value_.string_ == 0)) { - return (value_.string_ == other.value_.string_); - } - unsigned this_len; - unsigned other_len; - char const* this_str; - char const* other_str; - decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str); - decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str); - if (this_len != other_len) return false; - int comp = memcmp(this_str, other_str, this_len); - return comp == 0; - } - case arrayValue: - case objectValue: - return value_.map_->size() == other.value_.map_->size() && - (*value_.map_) == (*other.value_.map_); - default: - JSON_ASSERT_UNREACHABLE; - } - return false; // unreachable -} - -bool Value::operator!=(const Value& other) const { return !(*this == other); } - -const char* Value::asCString() const { - JSON_ASSERT_MESSAGE(type_ == stringValue, - "in Json::Value::asCString(): requires stringValue"); - if (value_.string_ == 0) return 0; - unsigned this_len; - char const* this_str; - decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str); - return this_str; -} - -bool Value::getString(char const** str, char const** cend) const { - if (type_ != stringValue) return false; - if (value_.string_ == 0) return false; - unsigned length; - decodePrefixedString(this->allocated_, this->value_.string_, &length, str); - *cend = *str + length; - return true; -} - -std::string Value::asString() const { - switch (type_) { - case nullValue: - return ""; - case stringValue: - { - if (value_.string_ == 0) return ""; - unsigned this_len; - char const* this_str; - decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str); - return std::string(this_str, this_len); - } - case booleanValue: - return value_.bool_ ? "true" : "false"; - case intValue: - return valueToString(value_.int_); - case uintValue: - return valueToString(value_.uint_); - case realValue: - return valueToString(value_.real_); - default: - JSON_FAIL_MESSAGE("Type is not convertible to string"); - } -} - -#ifdef JSON_USE_CPPTL -CppTL::ConstString Value::asConstString() const { - unsigned len; - char const* str; - decodePrefixedString(allocated_, value_.string_, - &len, &str); - return CppTL::ConstString(str, len); -} -#endif - -Value::Int Value::asInt() const { - switch (type_) { - case intValue: - JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range"); - return Int(value_.int_); - case uintValue: - JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range"); - return Int(value_.uint_); - case realValue: - JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt), - "double out of Int range"); - return Int(value_.real_); - case nullValue: - return 0; - case booleanValue: - return value_.bool_ ? 1 : 0; - default: - break; - } - JSON_FAIL_MESSAGE("Value is not convertible to Int."); -} - -Value::UInt Value::asUInt() const { - switch (type_) { - case intValue: - JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range"); - return UInt(value_.int_); - case uintValue: - JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range"); - return UInt(value_.uint_); - case realValue: - JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt), - "double out of UInt range"); - return UInt(value_.real_); - case nullValue: - return 0; - case booleanValue: - return value_.bool_ ? 1 : 0; - default: - break; - } - JSON_FAIL_MESSAGE("Value is not convertible to UInt."); -} - -#if defined(JSON_HAS_INT64) - -Value::Int64 Value::asInt64() const { - switch (type_) { - case intValue: - return Int64(value_.int_); - case uintValue: - JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range"); - return Int64(value_.uint_); - case realValue: - JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64), - "double out of Int64 range"); - return Int64(value_.real_); - case nullValue: - return 0; - case booleanValue: - return value_.bool_ ? 1 : 0; - default: - break; - } - JSON_FAIL_MESSAGE("Value is not convertible to Int64."); -} - -Value::UInt64 Value::asUInt64() const { - switch (type_) { - case intValue: - JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range"); - return UInt64(value_.int_); - case uintValue: - return UInt64(value_.uint_); - case realValue: - JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64), - "double out of UInt64 range"); - return UInt64(value_.real_); - case nullValue: - return 0; - case booleanValue: - return value_.bool_ ? 1 : 0; - default: - break; - } - JSON_FAIL_MESSAGE("Value is not convertible to UInt64."); -} -#endif // if defined(JSON_HAS_INT64) - -LargestInt Value::asLargestInt() const { -#if defined(JSON_NO_INT64) - return asInt(); -#else - return asInt64(); -#endif -} - -LargestUInt Value::asLargestUInt() const { -#if defined(JSON_NO_INT64) - return asUInt(); -#else - return asUInt64(); -#endif -} - -double Value::asDouble() const { - switch (type_) { - case intValue: - return static_cast(value_.int_); - case uintValue: -#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) - return static_cast(value_.uint_); -#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) - return integerToDouble(value_.uint_); -#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) - case realValue: - return value_.real_; - case nullValue: - return 0.0; - case booleanValue: - return value_.bool_ ? 1.0 : 0.0; - default: - break; - } - JSON_FAIL_MESSAGE("Value is not convertible to double."); -} - -float Value::asFloat() const { - switch (type_) { - case intValue: - return static_cast(value_.int_); - case uintValue: -#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) - return static_cast(value_.uint_); -#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) - return integerToDouble(value_.uint_); -#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) - case realValue: - return static_cast(value_.real_); - case nullValue: - return 0.0; - case booleanValue: - return value_.bool_ ? 1.0f : 0.0f; - default: - break; - } - JSON_FAIL_MESSAGE("Value is not convertible to float."); -} - -bool Value::asBool() const { - switch (type_) { - case booleanValue: - return value_.bool_; - case nullValue: - return false; - case intValue: - return value_.int_ ? true : false; - case uintValue: - return value_.uint_ ? true : false; - case realValue: - // This is kind of strange. Not recommended. - return (value_.real_ != 0.0) ? true : false; - default: - break; - } - JSON_FAIL_MESSAGE("Value is not convertible to bool."); -} - -bool Value::isConvertibleTo(ValueType other) const { - switch (other) { - case nullValue: - return (isNumeric() && asDouble() == 0.0) || - (type_ == booleanValue && value_.bool_ == false) || - (type_ == stringValue && asString() == "") || - (type_ == arrayValue && value_.map_->size() == 0) || - (type_ == objectValue && value_.map_->size() == 0) || - type_ == nullValue; - case intValue: - return isInt() || - (type_ == realValue && InRange(value_.real_, minInt, maxInt)) || - type_ == booleanValue || type_ == nullValue; - case uintValue: - return isUInt() || - (type_ == realValue && InRange(value_.real_, 0, maxUInt)) || - type_ == booleanValue || type_ == nullValue; - case realValue: - return isNumeric() || type_ == booleanValue || type_ == nullValue; - case booleanValue: - return isNumeric() || type_ == booleanValue || type_ == nullValue; - case stringValue: - return isNumeric() || type_ == booleanValue || type_ == stringValue || - type_ == nullValue; - case arrayValue: - return type_ == arrayValue || type_ == nullValue; - case objectValue: - return type_ == objectValue || type_ == nullValue; - } - JSON_ASSERT_UNREACHABLE; - return false; -} - -/// Number of values in array or object -ArrayIndex Value::size() const { - switch (type_) { - case nullValue: - case intValue: - case uintValue: - case realValue: - case booleanValue: - case stringValue: - return 0; - case arrayValue: // size of the array is highest index + 1 - if (!value_.map_->empty()) { - ObjectValues::const_iterator itLast = value_.map_->end(); - --itLast; - return (*itLast).first.index() + 1; - } - return 0; - case objectValue: - return ArrayIndex(value_.map_->size()); - } - JSON_ASSERT_UNREACHABLE; - return 0; // unreachable; -} - -bool Value::empty() const { - if (isNull() || isArray() || isObject()) - return size() == 0u; - else - return false; -} - -bool Value::operator!() const { return isNull(); } - -void Value::clear() { - JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue || - type_ == objectValue, - "in Json::Value::clear(): requires complex value"); - start_ = 0; - limit_ = 0; - switch (type_) { - case arrayValue: - case objectValue: - value_.map_->clear(); - break; - default: - break; - } -} - -void Value::resize(ArrayIndex newSize) { - JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue, - "in Json::Value::resize(): requires arrayValue"); - if (type_ == nullValue) - *this = Value(arrayValue); - ArrayIndex oldSize = size(); - if (newSize == 0) - clear(); - else if (newSize > oldSize) - (*this)[newSize - 1]; - else { - for (ArrayIndex index = newSize; index < oldSize; ++index) { - value_.map_->erase(index); - } - assert(size() == newSize); - } -} - -Value& Value::operator[](ArrayIndex index) { - JSON_ASSERT_MESSAGE( - type_ == nullValue || type_ == arrayValue, - "in Json::Value::operator[](ArrayIndex): requires arrayValue"); - if (type_ == nullValue) - *this = Value(arrayValue); - CZString key(index); - ObjectValues::iterator it = value_.map_->lower_bound(key); - if (it != value_.map_->end() && (*it).first == key) - return (*it).second; - - ObjectValues::value_type defaultValue(key, nullRef); - it = value_.map_->insert(it, defaultValue); - return (*it).second; -} - -Value& Value::operator[](int index) { - JSON_ASSERT_MESSAGE( - index >= 0, - "in Json::Value::operator[](int index): index cannot be negative"); - return (*this)[ArrayIndex(index)]; -} - -const Value& Value::operator[](ArrayIndex index) const { - JSON_ASSERT_MESSAGE( - type_ == nullValue || type_ == arrayValue, - "in Json::Value::operator[](ArrayIndex)const: requires arrayValue"); - if (type_ == nullValue) - return nullRef; - CZString key(index); - ObjectValues::const_iterator it = value_.map_->find(key); - if (it == value_.map_->end()) - return nullRef; - return (*it).second; -} - -const Value& Value::operator[](int index) const { - JSON_ASSERT_MESSAGE( - index >= 0, - "in Json::Value::operator[](int index) const: index cannot be negative"); - return (*this)[ArrayIndex(index)]; -} - -void Value::initBasic(ValueType vtype, bool allocated) { - type_ = vtype; - allocated_ = allocated; - comments_ = 0; - start_ = 0; - limit_ = 0; -} - -// Access an object value by name, create a null member if it does not exist. -// @pre Type of '*this' is object or null. -// @param key is null-terminated. -Value& Value::resolveReference(const char* key) { - JSON_ASSERT_MESSAGE( - type_ == nullValue || type_ == objectValue, - "in Json::Value::resolveReference(): requires objectValue"); - if (type_ == nullValue) - *this = Value(objectValue); - CZString actualKey( - key, static_cast(strlen(key)), CZString::noDuplication); // NOTE! - ObjectValues::iterator it = value_.map_->lower_bound(actualKey); - if (it != value_.map_->end() && (*it).first == actualKey) - return (*it).second; - - ObjectValues::value_type defaultValue(actualKey, nullRef); - it = value_.map_->insert(it, defaultValue); - Value& value = (*it).second; - return value; -} - -// @param key is not null-terminated. -Value& Value::resolveReference(char const* key, char const* cend) -{ - JSON_ASSERT_MESSAGE( - type_ == nullValue || type_ == objectValue, - "in Json::Value::resolveReference(key, end): requires objectValue"); - if (type_ == nullValue) - *this = Value(objectValue); - CZString actualKey( - key, static_cast(cend-key), CZString::duplicateOnCopy); - ObjectValues::iterator it = value_.map_->lower_bound(actualKey); - if (it != value_.map_->end() && (*it).first == actualKey) - return (*it).second; - - ObjectValues::value_type defaultValue(actualKey, nullRef); - it = value_.map_->insert(it, defaultValue); - Value& value = (*it).second; - return value; -} - -Value Value::get(ArrayIndex index, const Value& defaultValue) const { - const Value* value = &((*this)[index]); - return value == &nullRef ? defaultValue : *value; -} - -bool Value::isValidIndex(ArrayIndex index) const { return index < size(); } - -Value const* Value::find(char const* key, char const* cend) const -{ - JSON_ASSERT_MESSAGE( - type_ == nullValue || type_ == objectValue, - "in Json::Value::find(key, end, found): requires objectValue or nullValue"); - if (type_ == nullValue) return NULL; - CZString actualKey(key, static_cast(cend-key), CZString::noDuplication); - ObjectValues::const_iterator it = value_.map_->find(actualKey); - if (it == value_.map_->end()) return NULL; - return &(*it).second; -} -const Value& Value::operator[](const char* key) const -{ - Value const* found = find(key, key + strlen(key)); - if (!found) return nullRef; - return *found; -} -Value const& Value::operator[](std::string const& key) const -{ - Value const* found = find(key.data(), key.data() + key.length()); - if (!found) return nullRef; - return *found; -} - -Value& Value::operator[](const char* key) { - return resolveReference(key, key + strlen(key)); -} - -Value& Value::operator[](const std::string& key) { - return resolveReference(key.data(), key.data() + key.length()); -} - -Value& Value::operator[](const StaticString& key) { - return resolveReference(key.c_str()); -} - -#ifdef JSON_USE_CPPTL -Value& Value::operator[](const CppTL::ConstString& key) { - return resolveReference(key.c_str(), key.end_c_str()); -} -Value const& Value::operator[](CppTL::ConstString const& key) const -{ - Value const* found = find(key.c_str(), key.end_c_str()); - if (!found) return nullRef; - return *found; -} -#endif - -Value& Value::append(const Value& value) { return (*this)[size()] = value; } - -Value Value::get(char const* key, char const* cend, Value const& defaultValue) const -{ - Value const* found = find(key, cend); - return !found ? defaultValue : *found; -} -Value Value::get(char const* key, Value const& defaultValue) const -{ - return get(key, key + strlen(key), defaultValue); -} -Value Value::get(std::string const& key, Value const& defaultValue) const -{ - return get(key.data(), key.data() + key.length(), defaultValue); -} - - -bool Value::removeMember(const char* key, const char* cend, Value* removed) -{ - if (type_ != objectValue) { - return false; - } - CZString actualKey(key, static_cast(cend-key), CZString::noDuplication); - ObjectValues::iterator it = value_.map_->find(actualKey); - if (it == value_.map_->end()) - return false; - *removed = it->second; - value_.map_->erase(it); - return true; -} -bool Value::removeMember(const char* key, Value* removed) -{ - return removeMember(key, key + strlen(key), removed); -} -bool Value::removeMember(std::string const& key, Value* removed) -{ - return removeMember(key.data(), key.data() + key.length(), removed); -} -Value Value::removeMember(const char* key) -{ - JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue, - "in Json::Value::removeMember(): requires objectValue"); - if (type_ == nullValue) - return nullRef; - - Value removed; // null - removeMember(key, key + strlen(key), &removed); - return removed; // still null if removeMember() did nothing -} -Value Value::removeMember(const std::string& key) -{ - return removeMember(key.c_str()); -} - -bool Value::removeIndex(ArrayIndex index, Value* removed) { - if (type_ != arrayValue) { - return false; - } - CZString key(index); - ObjectValues::iterator it = value_.map_->find(key); - if (it == value_.map_->end()) { - return false; - } - *removed = it->second; - ArrayIndex oldSize = size(); - // shift left all items left, into the place of the "removed" - for (ArrayIndex i = index; i < (oldSize - 1); ++i){ - CZString keey(i); - (*value_.map_)[keey] = (*this)[i + 1]; - } - // erase the last one ("leftover") - CZString keyLast(oldSize - 1); - ObjectValues::iterator itLast = value_.map_->find(keyLast); - value_.map_->erase(itLast); - return true; -} - -#ifdef JSON_USE_CPPTL -Value Value::get(const CppTL::ConstString& key, - const Value& defaultValue) const { - return get(key.c_str(), key.end_c_str(), defaultValue); -} -#endif - -bool Value::isMember(char const* key, char const* cend) const -{ - Value const* value = find(key, cend); - return NULL != value; -} -bool Value::isMember(char const* key) const -{ - return isMember(key, key + strlen(key)); -} -bool Value::isMember(std::string const& key) const -{ - return isMember(key.data(), key.data() + key.length()); -} - -#ifdef JSON_USE_CPPTL -bool Value::isMember(const CppTL::ConstString& key) const { - return isMember(key.c_str(), key.end_c_str()); -} -#endif - -Value::Members Value::getMemberNames() const { - JSON_ASSERT_MESSAGE( - type_ == nullValue || type_ == objectValue, - "in Json::Value::getMemberNames(), value must be objectValue"); - if (type_ == nullValue) - return Value::Members(); - Members members; - members.reserve(value_.map_->size()); - ObjectValues::const_iterator it = value_.map_->begin(); - ObjectValues::const_iterator itEnd = value_.map_->end(); - for (; it != itEnd; ++it) { - members.push_back(std::string((*it).first.data(), - (*it).first.length())); - } - return members; -} -// -//# ifdef JSON_USE_CPPTL -// EnumMemberNames -// Value::enumMemberNames() const -//{ -// if ( type_ == objectValue ) -// { -// return CppTL::Enum::any( CppTL::Enum::transform( -// CppTL::Enum::keys( *(value_.map_), CppTL::Type() ), -// MemberNamesTransform() ) ); -// } -// return EnumMemberNames(); -//} -// -// -// EnumValues -// Value::enumValues() const -//{ -// if ( type_ == objectValue || type_ == arrayValue ) -// return CppTL::Enum::anyValues( *(value_.map_), -// CppTL::Type() ); -// return EnumValues(); -//} -// -//# endif - -static bool IsIntegral(double d) { - double integral_part; - return modf(d, &integral_part) == 0.0; -} - -bool Value::isNull() const { return type_ == nullValue; } - -bool Value::isBool() const { return type_ == booleanValue; } - -bool Value::isInt() const { - switch (type_) { - case intValue: - return value_.int_ >= minInt && value_.int_ <= maxInt; - case uintValue: - return value_.uint_ <= UInt(maxInt); - case realValue: - return value_.real_ >= minInt && value_.real_ <= maxInt && - IsIntegral(value_.real_); - default: - break; - } - return false; -} - -bool Value::isUInt() const { - switch (type_) { - case intValue: - return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt); - case uintValue: - return value_.uint_ <= maxUInt; - case realValue: - return value_.real_ >= 0 && value_.real_ <= maxUInt && - IsIntegral(value_.real_); - default: - break; - } - return false; -} - -bool Value::isInt64() const { -#if defined(JSON_HAS_INT64) - switch (type_) { - case intValue: - return true; - case uintValue: - return value_.uint_ <= UInt64(maxInt64); - case realValue: - // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a - // double, so double(maxInt64) will be rounded up to 2^63. Therefore we - // require the value to be strictly less than the limit. - return value_.real_ >= double(minInt64) && - value_.real_ < double(maxInt64) && IsIntegral(value_.real_); - default: - break; - } -#endif // JSON_HAS_INT64 - return false; -} - -bool Value::isUInt64() const { -#if defined(JSON_HAS_INT64) - switch (type_) { - case intValue: - return value_.int_ >= 0; - case uintValue: - return true; - case realValue: - // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a - // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we - // require the value to be strictly less than the limit. - return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble && - IsIntegral(value_.real_); - default: - break; - } -#endif // JSON_HAS_INT64 - return false; -} - -bool Value::isIntegral() const { -#if defined(JSON_HAS_INT64) - return isInt64() || isUInt64(); -#else - return isInt() || isUInt(); -#endif -} - -bool Value::isDouble() const { return type_ == realValue || isIntegral(); } - -bool Value::isNumeric() const { return isIntegral() || isDouble(); } - -bool Value::isString() const { return type_ == stringValue; } - -bool Value::isArray() const { return type_ == arrayValue; } - -bool Value::isObject() const { return type_ == objectValue; } - -void Value::setComment(const char* comment, size_t len, CommentPlacement placement) { - if (!comments_) - comments_ = new CommentInfo[numberOfCommentPlacement]; - if ((len > 0) && (comment[len-1] == '\n')) { - // Always discard trailing newline, to aid indentation. - len -= 1; - } - comments_[placement].setComment(comment, len); -} - -void Value::setComment(const char* comment, CommentPlacement placement) { - setComment(comment, strlen(comment), placement); -} - -void Value::setComment(const std::string& comment, CommentPlacement placement) { - setComment(comment.c_str(), comment.length(), placement); -} - -bool Value::hasComment(CommentPlacement placement) const { - return comments_ != 0 && comments_[placement].comment_ != 0; -} - -std::string Value::getComment(CommentPlacement placement) const { - if (hasComment(placement)) - return comments_[placement].comment_; - return ""; -} - -void Value::setOffsetStart(size_t start) { start_ = start; } - -void Value::setOffsetLimit(size_t limit) { limit_ = limit; } - -size_t Value::getOffsetStart() const { return start_; } - -size_t Value::getOffsetLimit() const { return limit_; } - -std::string Value::toStyledString() const { - StyledWriter writer; - return writer.write(*this); -} - -Value::const_iterator Value::begin() const { - switch (type_) { - case arrayValue: - case objectValue: - if (value_.map_) - return const_iterator(value_.map_->begin()); - break; - default: - break; - } - return const_iterator(); -} - -Value::const_iterator Value::end() const { - switch (type_) { - case arrayValue: - case objectValue: - if (value_.map_) - return const_iterator(value_.map_->end()); - break; - default: - break; - } - return const_iterator(); -} - -Value::iterator Value::begin() { - switch (type_) { - case arrayValue: - case objectValue: - if (value_.map_) - return iterator(value_.map_->begin()); - break; - default: - break; - } - return iterator(); -} - -Value::iterator Value::end() { - switch (type_) { - case arrayValue: - case objectValue: - if (value_.map_) - return iterator(value_.map_->end()); - break; - default: - break; - } - return iterator(); -} - -// class PathArgument -// ////////////////////////////////////////////////////////////////// - -PathArgument::PathArgument() : key_(), index_(), kind_(kindNone) {} - -PathArgument::PathArgument(ArrayIndex index) - : key_(), index_(index), kind_(kindIndex) {} - -PathArgument::PathArgument(const char* key) - : key_(key), index_(), kind_(kindKey) {} - -PathArgument::PathArgument(const std::string& key) - : key_(key.c_str()), index_(), kind_(kindKey) {} - -// class Path -// ////////////////////////////////////////////////////////////////// - -Path::Path(const std::string& path, - const PathArgument& a1, - const PathArgument& a2, - const PathArgument& a3, - const PathArgument& a4, - const PathArgument& a5) { - InArgs in; - in.push_back(&a1); - in.push_back(&a2); - in.push_back(&a3); - in.push_back(&a4); - in.push_back(&a5); - makePath(path, in); -} - -void Path::makePath(const std::string& path, const InArgs& in) { - const char* current = path.c_str(); - const char* end = current + path.length(); - InArgs::const_iterator itInArg = in.begin(); - while (current != end) { - if (*current == '[') { - ++current; - if (*current == '%') - addPathInArg(path, in, itInArg, PathArgument::kindIndex); - else { - ArrayIndex index = 0; - for (; current != end && *current >= '0' && *current <= '9'; ++current) - index = index * 10 + ArrayIndex(*current - '0'); - args_.push_back(index); - } - if (current == end || *current++ != ']') - invalidPath(path, int(current - path.c_str())); - } else if (*current == '%') { - addPathInArg(path, in, itInArg, PathArgument::kindKey); - ++current; - } else if (*current == '.') { - ++current; - } else { - const char* beginName = current; - while (current != end && !strchr("[.", *current)) - ++current; - args_.push_back(std::string(beginName, current)); - } - } -} - -void Path::addPathInArg(const std::string& /*path*/, - const InArgs& in, - InArgs::const_iterator& itInArg, - PathArgument::Kind kind) { - if (itInArg == in.end()) { - // Error: missing argument %d - } else if ((*itInArg)->kind_ != kind) { - // Error: bad argument type - } else { - args_.push_back(**itInArg); - } -} - -void Path::invalidPath(const std::string& /*path*/, int /*location*/) { - // Error: invalid path. -} - -const Value& Path::resolve(const Value& root) const { - const Value* node = &root; - for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) { - const PathArgument& arg = *it; - if (arg.kind_ == PathArgument::kindIndex) { - if (!node->isArray() || !node->isValidIndex(arg.index_)) { - // Error: unable to resolve path (array value expected at position... - } - node = &((*node)[arg.index_]); - } else if (arg.kind_ == PathArgument::kindKey) { - if (!node->isObject()) { - // Error: unable to resolve path (object value expected at position...) - } - node = &((*node)[arg.key_]); - if (node == &Value::nullRef) { - // Error: unable to resolve path (object has no member named '' at - // position...) - } - } - } - return *node; -} - -Value Path::resolve(const Value& root, const Value& defaultValue) const { - const Value* node = &root; - for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) { - const PathArgument& arg = *it; - if (arg.kind_ == PathArgument::kindIndex) { - if (!node->isArray() || !node->isValidIndex(arg.index_)) - return defaultValue; - node = &((*node)[arg.index_]); - } else if (arg.kind_ == PathArgument::kindKey) { - if (!node->isObject()) - return defaultValue; - node = &((*node)[arg.key_]); - if (node == &Value::nullRef) - return defaultValue; - } - } - return *node; -} - -Value& Path::make(Value& root) const { - Value* node = &root; - for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) { - const PathArgument& arg = *it; - if (arg.kind_ == PathArgument::kindIndex) { - if (!node->isArray()) { - // Error: node is not an array at position ... - } - node = &((*node)[arg.index_]); - } else if (arg.kind_ == PathArgument::kindKey) { - if (!node->isObject()) { - // Error: node is not an object at position... - } - node = &((*node)[arg.key_]); - } - } - return *node; -} - -} // namespace Json - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: src/lib_json/json_value.cpp -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: src/lib_json/json_writer.cpp -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2011 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#if !defined(JSON_IS_AMALGAMATION) -#include -#include "json_tool.h" -#endif // if !defined(JSON_IS_AMALGAMATION) -#include -#include -#include -#include -#include -#include -#include -#include - -#if defined(_MSC_VER) && _MSC_VER >= 1200 && _MSC_VER < 1800 // Between VC++ 6.0 and VC++ 11.0 -#include -#define isfinite _finite -#elif defined(__sun) && defined(__SVR4) //Solaris -#include -#define isfinite finite -#else -#include -#define isfinite std::isfinite -#endif - -#if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below -#define snprintf _snprintf -#elif defined(__ANDROID__) -#define snprintf snprintf -#elif __cplusplus >= 201103L -#define snprintf std::snprintf -#endif - -#if defined(__BORLANDC__) -#include -#define isfinite _finite -#define snprintf _snprintf -#endif - -#if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0 -// Disable warning about strdup being deprecated. -#pragma warning(disable : 4996) -#endif - -namespace Json { - -#if __cplusplus >= 201103L -typedef std::unique_ptr StreamWriterPtr; -#else -typedef std::auto_ptr StreamWriterPtr; -#endif - -static bool containsControlCharacter(const char* str) { - while (*str) { - if (isControlCharacter(*(str++))) - return true; - } - return false; -} - -static bool containsControlCharacter0(const char* str, unsigned len) { - char const* end = str + len; - while (end != str) { - if (isControlCharacter(*str) || 0==*str) - return true; - ++str; - } - return false; -} - -std::string valueToString(LargestInt value) { - UIntToStringBuffer buffer; - char* current = buffer + sizeof(buffer); - if (value == Value::minLargestInt) { - uintToString(LargestUInt(Value::maxLargestInt) + 1, current); - *--current = '-'; - } else if (value < 0) { - uintToString(LargestUInt(-value), current); - *--current = '-'; - } else { - uintToString(LargestUInt(value), current); - } - assert(current >= buffer); - return current; -} - -std::string valueToString(LargestUInt value) { - UIntToStringBuffer buffer; - char* current = buffer + sizeof(buffer); - uintToString(value, current); - assert(current >= buffer); - return current; -} - -#if defined(JSON_HAS_INT64) - -std::string valueToString(Int value) { - return valueToString(LargestInt(value)); -} - -std::string valueToString(UInt value) { - return valueToString(LargestUInt(value)); -} - -#endif // # if defined(JSON_HAS_INT64) - -std::string valueToString(double value) { - // Allocate a buffer that is more than large enough to store the 16 digits of - // precision requested below. - char buffer[32]; - int len = -1; - -// Print into the buffer. We need not request the alternative representation -// that always has a decimal point because JSON doesn't distingish the -// concepts of reals and integers. -#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with - // visual studio 2005 to - // avoid warning. -#if defined(WINCE) - len = _snprintf(buffer, sizeof(buffer), "%.17g", value); -#else - len = sprintf_s(buffer, sizeof(buffer), "%.17g", value); -#endif -#else - if (isfinite(value)) { - len = snprintf(buffer, sizeof(buffer), "%.17g", value); - } else { - // IEEE standard states that NaN values will not compare to themselves - if (value != value) { - len = snprintf(buffer, sizeof(buffer), "null"); - } else if (value < 0) { - len = snprintf(buffer, sizeof(buffer), "-1e+9999"); - } else { - len = snprintf(buffer, sizeof(buffer), "1e+9999"); - } - // For those, we do not need to call fixNumLoc, but it is fast. - } -#endif - assert(len >= 0); - fixNumericLocale(buffer, buffer + len); - return buffer; -} - -std::string valueToString(bool value) { return value ? "true" : "false"; } - -std::string valueToQuotedString(const char* value) { - if (value == NULL) - return ""; - // Not sure how to handle unicode... - if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL && - !containsControlCharacter(value)) - return std::string("\"") + value + "\""; - // We have to walk value and escape any special characters. - // Appending to std::string is not efficient, but this should be rare. - // (Note: forward slashes are *not* rare, but I am not escaping them.) - std::string::size_type maxsize = - strlen(value) * 2 + 3; // allescaped+quotes+NULL - std::string result; - result.reserve(maxsize); // to avoid lots of mallocs - result += "\""; - for (const char* c = value; *c != 0; ++c) { - switch (*c) { - case '\"': - result += "\\\""; - break; - case '\\': - result += "\\\\"; - break; - case '\b': - result += "\\b"; - break; - case '\f': - result += "\\f"; - break; - case '\n': - result += "\\n"; - break; - case '\r': - result += "\\r"; - break; - case '\t': - result += "\\t"; - break; - // case '/': - // Even though \/ is considered a legal escape in JSON, a bare - // slash is also legal, so I see no reason to escape it. - // (I hope I am not misunderstanding something. - // blep notes: actually escaping \/ may be useful in javascript to avoid (*c); - result += oss.str(); - } else { - result += *c; - } - break; - } - } - result += "\""; - return result; -} - -// https://github.com/upcaste/upcaste/blob/master/src/upcore/src/cstring/strnpbrk.cpp -static char const* strnpbrk(char const* s, char const* accept, size_t n) { - assert((s || !n) && accept); - - char const* const end = s + n; - for (char const* cur = s; cur < end; ++cur) { - int const c = *cur; - for (char const* a = accept; *a; ++a) { - if (*a == c) { - return cur; - } - } - } - return NULL; -} -static std::string valueToQuotedStringN(const char* value, unsigned length) { - if (value == NULL) - return ""; - // Not sure how to handle unicode... - if (strnpbrk(value, "\"\\\b\f\n\r\t", length) == NULL && - !containsControlCharacter0(value, length)) - return std::string("\"") + value + "\""; - // We have to walk value and escape any special characters. - // Appending to std::string is not efficient, but this should be rare. - // (Note: forward slashes are *not* rare, but I am not escaping them.) - std::string::size_type maxsize = - length * 2 + 3; // allescaped+quotes+NULL - std::string result; - result.reserve(maxsize); // to avoid lots of mallocs - result += "\""; - char const* end = value + length; - for (const char* c = value; c != end; ++c) { - switch (*c) { - case '\"': - result += "\\\""; - break; - case '\\': - result += "\\\\"; - break; - case '\b': - result += "\\b"; - break; - case '\f': - result += "\\f"; - break; - case '\n': - result += "\\n"; - break; - case '\r': - result += "\\r"; - break; - case '\t': - result += "\\t"; - break; - // case '/': - // Even though \/ is considered a legal escape in JSON, a bare - // slash is also legal, so I see no reason to escape it. - // (I hope I am not misunderstanding something.) - // blep notes: actually escaping \/ may be useful in javascript to avoid (*c); - result += oss.str(); - } else { - result += *c; - } - break; - } - } - result += "\""; - return result; -} - -// Class Writer -// ////////////////////////////////////////////////////////////////// -Writer::~Writer() {} - -// Class FastWriter -// ////////////////////////////////////////////////////////////////// - -FastWriter::FastWriter() - : yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false), - omitEndingLineFeed_(false) {} - -void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; } - -void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; } - -void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; } - -std::string FastWriter::write(const Value& root) { - document_ = ""; - writeValue(root); - if (!omitEndingLineFeed_) - document_ += "\n"; - return document_; -} - -void FastWriter::writeValue(const Value& value) { - switch (value.type()) { - case nullValue: - if (!dropNullPlaceholders_) - document_ += "null"; - break; - case intValue: - document_ += valueToString(value.asLargestInt()); - break; - case uintValue: - document_ += valueToString(value.asLargestUInt()); - break; - case realValue: - document_ += valueToString(value.asDouble()); - break; - case stringValue: - { - // Is NULL possible for value.string_? - char const* str; - char const* end; - bool ok = value.getString(&str, &end); - if (ok) document_ += valueToQuotedStringN(str, static_cast(end-str)); - break; - } - case booleanValue: - document_ += valueToString(value.asBool()); - break; - case arrayValue: { - document_ += '['; - int size = value.size(); - for (int index = 0; index < size; ++index) { - if (index > 0) - document_ += ','; - writeValue(value[index]); - } - document_ += ']'; - } break; - case objectValue: { - Value::Members members(value.getMemberNames()); - document_ += '{'; - for (Value::Members::iterator it = members.begin(); it != members.end(); - ++it) { - const std::string& name = *it; - if (it != members.begin()) - document_ += ','; - document_ += valueToQuotedStringN(name.data(), static_cast(name.length())); - document_ += yamlCompatiblityEnabled_ ? ": " : ":"; - writeValue(value[name]); - } - document_ += '}'; - } break; - } -} - -// Class StyledWriter -// ////////////////////////////////////////////////////////////////// - -StyledWriter::StyledWriter() - : rightMargin_(74), indentSize_(3), addChildValues_() {} - -std::string StyledWriter::write(const Value& root) { - document_ = ""; - addChildValues_ = false; - indentString_ = ""; - writeCommentBeforeValue(root); - writeValue(root); - writeCommentAfterValueOnSameLine(root); - document_ += "\n"; - return document_; -} - -void StyledWriter::writeValue(const Value& value) { - switch (value.type()) { - case nullValue: - pushValue("null"); - break; - case intValue: - pushValue(valueToString(value.asLargestInt())); - break; - case uintValue: - pushValue(valueToString(value.asLargestUInt())); - break; - case realValue: - pushValue(valueToString(value.asDouble())); - break; - case stringValue: - { - // Is NULL possible for value.string_? - char const* str; - char const* end; - bool ok = value.getString(&str, &end); - if (ok) pushValue(valueToQuotedStringN(str, static_cast(end-str))); - else pushValue(""); - break; - } - case booleanValue: - pushValue(valueToString(value.asBool())); - break; - case arrayValue: - writeArrayValue(value); - break; - case objectValue: { - Value::Members members(value.getMemberNames()); - if (members.empty()) - pushValue("{}"); - else { - writeWithIndent("{"); - indent(); - Value::Members::iterator it = members.begin(); - for (;;) { - const std::string& name = *it; - const Value& childValue = value[name]; - writeCommentBeforeValue(childValue); - writeWithIndent(valueToQuotedString(name.c_str())); - document_ += " : "; - writeValue(childValue); - if (++it == members.end()) { - writeCommentAfterValueOnSameLine(childValue); - break; - } - document_ += ','; - writeCommentAfterValueOnSameLine(childValue); - } - unindent(); - writeWithIndent("}"); - } - } break; - } -} - -void StyledWriter::writeArrayValue(const Value& value) { - unsigned size = value.size(); - if (size == 0) - pushValue("[]"); - else { - bool isArrayMultiLine = isMultineArray(value); - if (isArrayMultiLine) { - writeWithIndent("["); - indent(); - bool hasChildValue = !childValues_.empty(); - unsigned index = 0; - for (;;) { - const Value& childValue = value[index]; - writeCommentBeforeValue(childValue); - if (hasChildValue) - writeWithIndent(childValues_[index]); - else { - writeIndent(); - writeValue(childValue); - } - if (++index == size) { - writeCommentAfterValueOnSameLine(childValue); - break; - } - document_ += ','; - writeCommentAfterValueOnSameLine(childValue); - } - unindent(); - writeWithIndent("]"); - } else // output on a single line - { - assert(childValues_.size() == size); - document_ += "[ "; - for (unsigned index = 0; index < size; ++index) { - if (index > 0) - document_ += ", "; - document_ += childValues_[index]; - } - document_ += " ]"; - } - } -} - -bool StyledWriter::isMultineArray(const Value& value) { - int size = value.size(); - bool isMultiLine = size * 3 >= rightMargin_; - childValues_.clear(); - for (int index = 0; index < size && !isMultiLine; ++index) { - const Value& childValue = value[index]; - isMultiLine = - isMultiLine || ((childValue.isArray() || childValue.isObject()) && - childValue.size() > 0); - } - if (!isMultiLine) // check if line length > max line length - { - childValues_.reserve(size); - addChildValues_ = true; - int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]' - for (int index = 0; index < size; ++index) { - if (hasCommentForValue(value[index])) { - isMultiLine = true; - } - writeValue(value[index]); - lineLength += int(childValues_[index].length()); - } - addChildValues_ = false; - isMultiLine = isMultiLine || lineLength >= rightMargin_; - } - return isMultiLine; -} - -void StyledWriter::pushValue(const std::string& value) { - if (addChildValues_) - childValues_.push_back(value); - else - document_ += value; -} - -void StyledWriter::writeIndent() { - if (!document_.empty()) { - char last = document_[document_.length() - 1]; - if (last == ' ') // already indented - return; - if (last != '\n') // Comments may add new-line - document_ += '\n'; - } - document_ += indentString_; -} - -void StyledWriter::writeWithIndent(const std::string& value) { - writeIndent(); - document_ += value; -} - -void StyledWriter::indent() { indentString_ += std::string(indentSize_, ' '); } - -void StyledWriter::unindent() { - assert(int(indentString_.size()) >= indentSize_); - indentString_.resize(indentString_.size() - indentSize_); -} - -void StyledWriter::writeCommentBeforeValue(const Value& root) { - if (!root.hasComment(commentBefore)) - return; - - document_ += "\n"; - writeIndent(); - const std::string& comment = root.getComment(commentBefore); - std::string::const_iterator iter = comment.begin(); - while (iter != comment.end()) { - document_ += *iter; - if (*iter == '\n' && - (iter != comment.end() && *(iter + 1) == '/')) - writeIndent(); - ++iter; - } - - // Comments are stripped of trailing newlines, so add one here - document_ += "\n"; -} - -void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) { - if (root.hasComment(commentAfterOnSameLine)) - document_ += " " + root.getComment(commentAfterOnSameLine); - - if (root.hasComment(commentAfter)) { - document_ += "\n"; - document_ += root.getComment(commentAfter); - document_ += "\n"; - } -} - -bool StyledWriter::hasCommentForValue(const Value& value) { - return value.hasComment(commentBefore) || - value.hasComment(commentAfterOnSameLine) || - value.hasComment(commentAfter); -} - -// Class StyledStreamWriter -// ////////////////////////////////////////////////////////////////// - -StyledStreamWriter::StyledStreamWriter(std::string indentation) - : document_(NULL), rightMargin_(74), indentation_(indentation), - addChildValues_() {} - -void StyledStreamWriter::write(std::ostream& out, const Value& root) { - document_ = &out; - addChildValues_ = false; - indentString_ = ""; - indented_ = true; - writeCommentBeforeValue(root); - if (!indented_) writeIndent(); - indented_ = true; - writeValue(root); - writeCommentAfterValueOnSameLine(root); - *document_ << "\n"; - document_ = NULL; // Forget the stream, for safety. -} - -void StyledStreamWriter::writeValue(const Value& value) { - switch (value.type()) { - case nullValue: - pushValue("null"); - break; - case intValue: - pushValue(valueToString(value.asLargestInt())); - break; - case uintValue: - pushValue(valueToString(value.asLargestUInt())); - break; - case realValue: - pushValue(valueToString(value.asDouble())); - break; - case stringValue: - { - // Is NULL possible for value.string_? - char const* str; - char const* end; - bool ok = value.getString(&str, &end); - if (ok) pushValue(valueToQuotedStringN(str, static_cast(end-str))); - else pushValue(""); - break; - } - case booleanValue: - pushValue(valueToString(value.asBool())); - break; - case arrayValue: - writeArrayValue(value); - break; - case objectValue: { - Value::Members members(value.getMemberNames()); - if (members.empty()) - pushValue("{}"); - else { - writeWithIndent("{"); - indent(); - Value::Members::iterator it = members.begin(); - for (;;) { - const std::string& name = *it; - const Value& childValue = value[name]; - writeCommentBeforeValue(childValue); - writeWithIndent(valueToQuotedString(name.c_str())); - *document_ << " : "; - writeValue(childValue); - if (++it == members.end()) { - writeCommentAfterValueOnSameLine(childValue); - break; - } - *document_ << ","; - writeCommentAfterValueOnSameLine(childValue); - } - unindent(); - writeWithIndent("}"); - } - } break; - } -} - -void StyledStreamWriter::writeArrayValue(const Value& value) { - unsigned size = value.size(); - if (size == 0) - pushValue("[]"); - else { - bool isArrayMultiLine = isMultineArray(value); - if (isArrayMultiLine) { - writeWithIndent("["); - indent(); - bool hasChildValue = !childValues_.empty(); - unsigned index = 0; - for (;;) { - const Value& childValue = value[index]; - writeCommentBeforeValue(childValue); - if (hasChildValue) - writeWithIndent(childValues_[index]); - else { - if (!indented_) writeIndent(); - indented_ = true; - writeValue(childValue); - indented_ = false; - } - if (++index == size) { - writeCommentAfterValueOnSameLine(childValue); - break; - } - *document_ << ","; - writeCommentAfterValueOnSameLine(childValue); - } - unindent(); - writeWithIndent("]"); - } else // output on a single line - { - assert(childValues_.size() == size); - *document_ << "[ "; - for (unsigned index = 0; index < size; ++index) { - if (index > 0) - *document_ << ", "; - *document_ << childValues_[index]; - } - *document_ << " ]"; - } - } -} - -bool StyledStreamWriter::isMultineArray(const Value& value) { - int size = value.size(); - bool isMultiLine = size * 3 >= rightMargin_; - childValues_.clear(); - for (int index = 0; index < size && !isMultiLine; ++index) { - const Value& childValue = value[index]; - isMultiLine = - isMultiLine || ((childValue.isArray() || childValue.isObject()) && - childValue.size() > 0); - } - if (!isMultiLine) // check if line length > max line length - { - childValues_.reserve(size); - addChildValues_ = true; - int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]' - for (int index = 0; index < size; ++index) { - if (hasCommentForValue(value[index])) { - isMultiLine = true; - } - writeValue(value[index]); - lineLength += int(childValues_[index].length()); - } - addChildValues_ = false; - isMultiLine = isMultiLine || lineLength >= rightMargin_; - } - return isMultiLine; -} - -void StyledStreamWriter::pushValue(const std::string& value) { - if (addChildValues_) - childValues_.push_back(value); - else - *document_ << value; -} - -void StyledStreamWriter::writeIndent() { - // blep intended this to look at the so-far-written string - // to determine whether we are already indented, but - // with a stream we cannot do that. So we rely on some saved state. - // The caller checks indented_. - *document_ << '\n' << indentString_; -} - -void StyledStreamWriter::writeWithIndent(const std::string& value) { - if (!indented_) writeIndent(); - *document_ << value; - indented_ = false; -} - -void StyledStreamWriter::indent() { indentString_ += indentation_; } - -void StyledStreamWriter::unindent() { - assert(indentString_.size() >= indentation_.size()); - indentString_.resize(indentString_.size() - indentation_.size()); -} - -void StyledStreamWriter::writeCommentBeforeValue(const Value& root) { - if (!root.hasComment(commentBefore)) - return; - - if (!indented_) writeIndent(); - const std::string& comment = root.getComment(commentBefore); - std::string::const_iterator iter = comment.begin(); - while (iter != comment.end()) { - *document_ << *iter; - if (*iter == '\n' && - (iter != comment.end() && *(iter + 1) == '/')) - // writeIndent(); // would include newline - *document_ << indentString_; - ++iter; - } - indented_ = false; -} - -void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) { - if (root.hasComment(commentAfterOnSameLine)) - *document_ << ' ' << root.getComment(commentAfterOnSameLine); - - if (root.hasComment(commentAfter)) { - writeIndent(); - *document_ << root.getComment(commentAfter); - } - indented_ = false; -} - -bool StyledStreamWriter::hasCommentForValue(const Value& value) { - return value.hasComment(commentBefore) || - value.hasComment(commentAfterOnSameLine) || - value.hasComment(commentAfter); -} - -////////////////////////// -// BuiltStyledStreamWriter - -/// Scoped enums are not available until C++11. -struct CommentStyle { - /// Decide whether to write comments. - enum Enum { - None, ///< Drop all comments. - Most, ///< Recover odd behavior of previous versions (not implemented yet). - All ///< Keep all comments. - }; -}; - -struct BuiltStyledStreamWriter : public StreamWriter -{ - BuiltStyledStreamWriter( - std::string const& indentation, - CommentStyle::Enum cs, - std::string const& colonSymbol, - std::string const& nullSymbol, - std::string const& endingLineFeedSymbol); - virtual int write(Value const& root, std::ostream* sout); -private: - void writeValue(Value const& value); - void writeArrayValue(Value const& value); - bool isMultineArray(Value const& value); - void pushValue(std::string const& value); - void writeIndent(); - void writeWithIndent(std::string const& value); - void indent(); - void unindent(); - void writeCommentBeforeValue(Value const& root); - void writeCommentAfterValueOnSameLine(Value const& root); - static bool hasCommentForValue(const Value& value); - - typedef std::vector ChildValues; - - ChildValues childValues_; - std::string indentString_; - int rightMargin_; - std::string indentation_; - CommentStyle::Enum cs_; - std::string colonSymbol_; - std::string nullSymbol_; - std::string endingLineFeedSymbol_; - bool addChildValues_ : 1; - bool indented_ : 1; -}; -BuiltStyledStreamWriter::BuiltStyledStreamWriter( - std::string const& indentation, - CommentStyle::Enum cs, - std::string const& colonSymbol, - std::string const& nullSymbol, - std::string const& endingLineFeedSymbol) - : rightMargin_(74) - , indentation_(indentation) - , cs_(cs) - , colonSymbol_(colonSymbol) - , nullSymbol_(nullSymbol) - , endingLineFeedSymbol_(endingLineFeedSymbol) - , addChildValues_(false) - , indented_(false) -{ -} -int BuiltStyledStreamWriter::write(Value const& root, std::ostream* sout) -{ - sout_ = sout; - addChildValues_ = false; - indented_ = true; - indentString_ = ""; - writeCommentBeforeValue(root); - if (!indented_) writeIndent(); - indented_ = true; - writeValue(root); - writeCommentAfterValueOnSameLine(root); - *sout_ << endingLineFeedSymbol_; - sout_ = NULL; - return 0; -} -void BuiltStyledStreamWriter::writeValue(Value const& value) { - switch (value.type()) { - case nullValue: - pushValue(nullSymbol_); - break; - case intValue: - pushValue(valueToString(value.asLargestInt())); - break; - case uintValue: - pushValue(valueToString(value.asLargestUInt())); - break; - case realValue: - pushValue(valueToString(value.asDouble())); - break; - case stringValue: - { - // Is NULL is possible for value.string_? - char const* str; - char const* end; - bool ok = value.getString(&str, &end); - if (ok) pushValue(valueToQuotedStringN(str, static_cast(end-str))); - else pushValue(""); - break; - } - case booleanValue: - pushValue(valueToString(value.asBool())); - break; - case arrayValue: - writeArrayValue(value); - break; - case objectValue: { - Value::Members members(value.getMemberNames()); - if (members.empty()) - pushValue("{}"); - else { - writeWithIndent("{"); - indent(); - Value::Members::iterator it = members.begin(); - for (;;) { - std::string const& name = *it; - Value const& childValue = value[name]; - writeCommentBeforeValue(childValue); - writeWithIndent(valueToQuotedStringN(name.data(), static_cast(name.length()))); - *sout_ << colonSymbol_; - writeValue(childValue); - if (++it == members.end()) { - writeCommentAfterValueOnSameLine(childValue); - break; - } - *sout_ << ","; - writeCommentAfterValueOnSameLine(childValue); - } - unindent(); - writeWithIndent("}"); - } - } break; - } -} - -void BuiltStyledStreamWriter::writeArrayValue(Value const& value) { - unsigned size = value.size(); - if (size == 0) - pushValue("[]"); - else { - bool isMultiLine = (cs_ == CommentStyle::All) || isMultineArray(value); - if (isMultiLine) { - writeWithIndent("["); - indent(); - bool hasChildValue = !childValues_.empty(); - unsigned index = 0; - for (;;) { - Value const& childValue = value[index]; - writeCommentBeforeValue(childValue); - if (hasChildValue) - writeWithIndent(childValues_[index]); - else { - if (!indented_) writeIndent(); - indented_ = true; - writeValue(childValue); - indented_ = false; - } - if (++index == size) { - writeCommentAfterValueOnSameLine(childValue); - break; - } - *sout_ << ","; - writeCommentAfterValueOnSameLine(childValue); - } - unindent(); - writeWithIndent("]"); - } else // output on a single line - { - assert(childValues_.size() == size); - *sout_ << "["; - if (!indentation_.empty()) *sout_ << " "; - for (unsigned index = 0; index < size; ++index) { - if (index > 0) - *sout_ << ", "; - *sout_ << childValues_[index]; - } - if (!indentation_.empty()) *sout_ << " "; - *sout_ << "]"; - } - } -} - -bool BuiltStyledStreamWriter::isMultineArray(Value const& value) { - int size = value.size(); - bool isMultiLine = size * 3 >= rightMargin_; - childValues_.clear(); - for (int index = 0; index < size && !isMultiLine; ++index) { - Value const& childValue = value[index]; - isMultiLine = - isMultiLine || ((childValue.isArray() || childValue.isObject()) && - childValue.size() > 0); - } - if (!isMultiLine) // check if line length > max line length - { - childValues_.reserve(size); - addChildValues_ = true; - int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]' - for (int index = 0; index < size; ++index) { - if (hasCommentForValue(value[index])) { - isMultiLine = true; - } - writeValue(value[index]); - lineLength += int(childValues_[index].length()); - } - addChildValues_ = false; - isMultiLine = isMultiLine || lineLength >= rightMargin_; - } - return isMultiLine; -} - -void BuiltStyledStreamWriter::pushValue(std::string const& value) { - if (addChildValues_) - childValues_.push_back(value); - else - *sout_ << value; -} - -void BuiltStyledStreamWriter::writeIndent() { - // blep intended this to look at the so-far-written string - // to determine whether we are already indented, but - // with a stream we cannot do that. So we rely on some saved state. - // The caller checks indented_. - - if (!indentation_.empty()) { - // In this case, drop newlines too. - *sout_ << '\n' << indentString_; - } -} - -void BuiltStyledStreamWriter::writeWithIndent(std::string const& value) { - if (!indented_) writeIndent(); - *sout_ << value; - indented_ = false; -} - -void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; } - -void BuiltStyledStreamWriter::unindent() { - assert(indentString_.size() >= indentation_.size()); - indentString_.resize(indentString_.size() - indentation_.size()); -} - -void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) { - if (cs_ == CommentStyle::None) return; - if (!root.hasComment(commentBefore)) - return; - - if (!indented_) writeIndent(); - const std::string& comment = root.getComment(commentBefore); - std::string::const_iterator iter = comment.begin(); - while (iter != comment.end()) { - *sout_ << *iter; - if (*iter == '\n' && - (iter != comment.end() && *(iter + 1) == '/')) - // writeIndent(); // would write extra newline - *sout_ << indentString_; - ++iter; - } - indented_ = false; -} - -void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Value const& root) { - if (cs_ == CommentStyle::None) return; - if (root.hasComment(commentAfterOnSameLine)) - *sout_ << " " + root.getComment(commentAfterOnSameLine); - - if (root.hasComment(commentAfter)) { - writeIndent(); - *sout_ << root.getComment(commentAfter); - } -} - -// static -bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) { - return value.hasComment(commentBefore) || - value.hasComment(commentAfterOnSameLine) || - value.hasComment(commentAfter); -} - -/////////////// -// StreamWriter - -StreamWriter::StreamWriter() - : sout_(NULL) -{ -} -StreamWriter::~StreamWriter() -{ -} -StreamWriter::Factory::~Factory() -{} -StreamWriterBuilder::StreamWriterBuilder() -{ - setDefaults(&settings_); -} -StreamWriterBuilder::~StreamWriterBuilder() -{} -StreamWriter* StreamWriterBuilder::newStreamWriter() const -{ - std::string indentation = settings_["indentation"].asString(); - std::string cs_str = settings_["commentStyle"].asString(); - bool eyc = settings_["enableYAMLCompatibility"].asBool(); - bool dnp = settings_["dropNullPlaceholders"].asBool(); - CommentStyle::Enum cs = CommentStyle::All; - if (cs_str == "All") { - cs = CommentStyle::All; - } else if (cs_str == "None") { - cs = CommentStyle::None; - } else { - throwRuntimeError("commentStyle must be 'All' or 'None'"); - } - std::string colonSymbol = " : "; - if (eyc) { - colonSymbol = ": "; - } else if (indentation.empty()) { - colonSymbol = ":"; - } - std::string nullSymbol = "null"; - if (dnp) { - nullSymbol = ""; - } - std::string endingLineFeedSymbol = ""; - return new BuiltStyledStreamWriter( - indentation, cs, - colonSymbol, nullSymbol, endingLineFeedSymbol); -} -static void getValidWriterKeys(std::set* valid_keys) -{ - valid_keys->clear(); - valid_keys->insert("indentation"); - valid_keys->insert("commentStyle"); - valid_keys->insert("enableYAMLCompatibility"); - valid_keys->insert("dropNullPlaceholders"); -} -bool StreamWriterBuilder::validate(Json::Value* invalid) const -{ - Json::Value my_invalid; - if (!invalid) invalid = &my_invalid; // so we do not need to test for NULL - Json::Value& inv = *invalid; - std::set valid_keys; - getValidWriterKeys(&valid_keys); - Value::Members keys = settings_.getMemberNames(); - size_t n = keys.size(); - for (size_t i = 0; i < n; ++i) { - std::string const& key = keys[i]; - if (valid_keys.find(key) == valid_keys.end()) { - inv[key] = settings_[key]; - } - } - return 0u == inv.size(); -} -Value& StreamWriterBuilder::operator[](std::string key) -{ - return settings_[key]; -} -// static -void StreamWriterBuilder::setDefaults(Json::Value* settings) -{ - //! [StreamWriterBuilderDefaults] - (*settings)["commentStyle"] = "All"; - (*settings)["indentation"] = "\t"; - (*settings)["enableYAMLCompatibility"] = false; - (*settings)["dropNullPlaceholders"] = false; - //! [StreamWriterBuilderDefaults] -} - -std::string writeString(StreamWriter::Factory const& builder, Value const& root) { - std::ostringstream sout; - StreamWriterPtr const writer(builder.newStreamWriter()); - writer->write(root, &sout); - return sout.str(); -} - -std::ostream& operator<<(std::ostream& sout, Value const& root) { - StreamWriterBuilder builder; - StreamWriterPtr const writer(builder.newStreamWriter()); - writer->write(root, &sout); - return sout; -} - -} // namespace Json - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: src/lib_json/json_writer.cpp -// ////////////////////////////////////////////////////////////////////// - - - - - diff --git a/depends/jsoncpp/jsoncpp.h b/depends/jsoncpp/jsoncpp.h deleted file mode 100644 index da3807d310..0000000000 --- a/depends/jsoncpp/jsoncpp.h +++ /dev/null @@ -1,2031 +0,0 @@ -/// Json-cpp amalgated header (http://jsoncpp.sourceforge.net/). -/// It is intended to be used with #include "json/json.h" - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: LICENSE -// ////////////////////////////////////////////////////////////////////// - -/* -The JsonCpp library's source code, including accompanying documentation, -tests and demonstration applications, are licensed under the following -conditions... - -The author (Baptiste Lepilleur) explicitly disclaims copyright in all -jurisdictions which recognize such a disclaimer. In such jurisdictions, -this software is released into the Public Domain. - -In jurisdictions which do not recognize Public Domain property (e.g. Germany as of -2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is -released under the terms of the MIT License (see below). - -In jurisdictions which recognize Public Domain property, the user of this -software may choose to accept it either as 1) Public Domain, 2) under the -conditions of the MIT License (see below), or 3) under the terms of dual -Public Domain/MIT License conditions described here, as they choose. - -The MIT License is about as close to Public Domain as a license can get, and is -described in clear, concise terms at: - - http://en.wikipedia.org/wiki/MIT_License - -The full text of the MIT License follows: - -======================================================================== -Copyright (c) 2007-2010 Baptiste Lepilleur - -Permission is hereby granted, free of charge, to any person -obtaining a copy of this software and associated documentation -files (the "Software"), to deal in the Software without -restriction, including without limitation the rights to use, copy, -modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS -BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN -ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -======================================================================== -(END LICENSE TEXT) - -The MIT license is compatible with both the GPL and commercial -software, affording one all of the rights of Public Domain with the -minor nuisance of being required to keep the above copyright notice -and license text in the source code. Note also that by accepting the -Public Domain "license" you can re-license your copy using whatever -license you like. - -*/ - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: LICENSE -// ////////////////////////////////////////////////////////////////////// - - - - - -#ifndef JSON_AMALGATED_H_INCLUDED -# define JSON_AMALGATED_H_INCLUDED -/// If defined, indicates that the source file is amalgated -/// to prevent private header inclusion. -#define JSON_IS_AMALGAMATION - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: include/json/version.h -// ////////////////////////////////////////////////////////////////////// - -// DO NOT EDIT. This file (and "version") is generated by CMake. -// Run CMake configure step to update it. -#ifndef JSON_VERSION_H_INCLUDED -# define JSON_VERSION_H_INCLUDED - -# define JSONCPP_VERSION_STRING "1.6.5" -# define JSONCPP_VERSION_MAJOR 1 -# define JSONCPP_VERSION_MINOR 6 -# define JSONCPP_VERSION_PATCH 5 -# define JSONCPP_VERSION_QUALIFIER -# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8)) - -#endif // JSON_VERSION_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: include/json/version.h -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: include/json/config.h -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#ifndef JSON_CONFIG_H_INCLUDED -#define JSON_CONFIG_H_INCLUDED - -/// If defined, indicates that json library is embedded in CppTL library. -//# define JSON_IN_CPPTL 1 - -/// If defined, indicates that json may leverage CppTL library -//# define JSON_USE_CPPTL 1 -/// If defined, indicates that cpptl vector based map should be used instead of -/// std::map -/// as Value container. -//# define JSON_USE_CPPTL_SMALLMAP 1 - -// If non-zero, the library uses exceptions to report bad input instead of C -// assertion macros. The default is to use exceptions. -#ifndef JSON_USE_EXCEPTION -#define JSON_USE_EXCEPTION 1 -#endif - -/// If defined, indicates that the source file is amalgated -/// to prevent private header inclusion. -/// Remarks: it is automatically defined in the generated amalgated header. -// #define JSON_IS_AMALGAMATION - -#ifdef JSON_IN_CPPTL -#include -#ifndef JSON_USE_CPPTL -#define JSON_USE_CPPTL 1 -#endif -#endif - -#ifdef JSON_IN_CPPTL -#define JSON_API CPPTL_API -#elif defined(JSON_DLL_BUILD) -#if defined(_MSC_VER) -#define JSON_API __declspec(dllexport) -#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING -#endif // if defined(_MSC_VER) -#elif defined(JSON_DLL) -#if defined(_MSC_VER) -#define JSON_API __declspec(dllimport) -#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING -#endif // if defined(_MSC_VER) -#endif // ifdef JSON_IN_CPPTL -#if !defined(JSON_API) -#define JSON_API -#endif - -// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for -// integer -// Storages, and 64 bits integer support is disabled. -// #define JSON_NO_INT64 1 - -#if defined(_MSC_VER) && _MSC_VER <= 1200 // MSVC 6 -// Microsoft Visual Studio 6 only support conversion from __int64 to double -// (no conversion from unsigned __int64). -#define JSON_USE_INT64_DOUBLE_CONVERSION 1 -// Disable warning 4786 for VS6 caused by STL (identifier was truncated to '255' -// characters in the debug information) -// All projects I've ever seen with VS6 were using this globally (not bothering -// with pragma push/pop). -#pragma warning(disable : 4786) -#endif // if defined(_MSC_VER) && _MSC_VER < 1200 // MSVC 6 - -#if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008 -/// Indicates that the following function is deprecated. -#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message)) -#elif defined(__clang__) && defined(__has_feature) -#if __has_feature(attribute_deprecated_with_message) -#define JSONCPP_DEPRECATED(message) __attribute__ ((deprecated(message))) -#endif -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) -#define JSONCPP_DEPRECATED(message) __attribute__ ((deprecated(message))) -#elif defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) -#define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__)) -#endif - -#if !defined(JSONCPP_DEPRECATED) -#define JSONCPP_DEPRECATED(message) -#endif // if !defined(JSONCPP_DEPRECATED) - -namespace Json { -typedef int Int; -typedef unsigned int UInt; -#if defined(JSON_NO_INT64) -typedef int LargestInt; -typedef unsigned int LargestUInt; -#undef JSON_HAS_INT64 -#else // if defined(JSON_NO_INT64) -// For Microsoft Visual use specific types as long long is not supported -#if defined(_MSC_VER) // Microsoft Visual Studio -typedef __int64 Int64; -typedef unsigned __int64 UInt64; -#else // if defined(_MSC_VER) // Other platforms, use long long -typedef long long int Int64; -typedef unsigned long long int UInt64; -#endif // if defined(_MSC_VER) -typedef Int64 LargestInt; -typedef UInt64 LargestUInt; -#define JSON_HAS_INT64 -#endif // if defined(JSON_NO_INT64) -} // end namespace Json - -#endif // JSON_CONFIG_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: include/json/config.h -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: include/json/forwards.h -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#ifndef JSON_FORWARDS_H_INCLUDED -#define JSON_FORWARDS_H_INCLUDED - -#if !defined(JSON_IS_AMALGAMATION) -#include "config.h" -#endif // if !defined(JSON_IS_AMALGAMATION) - -namespace Json { - -// writer.h -class FastWriter; -class StyledWriter; - -// reader.h -class Reader; - -// features.h -class Features; - -// value.h -typedef unsigned int ArrayIndex; -class StaticString; -class Path; -class PathArgument; -class Value; -class ValueIteratorBase; -class ValueIterator; -class ValueConstIterator; - -} // namespace Json - -#endif // JSON_FORWARDS_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: include/json/forwards.h -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: include/json/features.h -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#ifndef CPPTL_JSON_FEATURES_H_INCLUDED -#define CPPTL_JSON_FEATURES_H_INCLUDED - -#if !defined(JSON_IS_AMALGAMATION) -#include "forwards.h" -#endif // if !defined(JSON_IS_AMALGAMATION) - -namespace Json { - -/** \brief Configuration passed to reader and writer. - * This configuration object can be used to force the Reader or Writer - * to behave in a standard conforming way. - */ -class JSON_API Features { -public: - /** \brief A configuration that allows all features and assumes all strings - * are UTF-8. - * - C & C++ comments are allowed - * - Root object can be any JSON value - * - Assumes Value strings are encoded in UTF-8 - */ - static Features all(); - - /** \brief A configuration that is strictly compatible with the JSON - * specification. - * - Comments are forbidden. - * - Root object must be either an array or an object value. - * - Assumes Value strings are encoded in UTF-8 - */ - static Features strictMode(); - - /** \brief Initialize the configuration like JsonConfig::allFeatures; - */ - Features(); - - /// \c true if comments are allowed. Default: \c true. - bool allowComments_; - - /// \c true if root must be either an array or an object value. Default: \c - /// false. - bool strictRoot_; - - /// \c true if dropped null placeholders are allowed. Default: \c false. - bool allowDroppedNullPlaceholders_; - - /// \c true if numeric object key are allowed. Default: \c false. - bool allowNumericKeys_; -}; - -} // namespace Json - -#endif // CPPTL_JSON_FEATURES_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: include/json/features.h -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: include/json/value.h -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#ifndef CPPTL_JSON_H_INCLUDED -#define CPPTL_JSON_H_INCLUDED - -#if !defined(JSON_IS_AMALGAMATION) -#include "forwards.h" -#endif // if !defined(JSON_IS_AMALGAMATION) -#include -#include -#include - -#ifndef JSON_USE_CPPTL_SMALLMAP -#include -#else -#include -#endif -#ifdef JSON_USE_CPPTL -#include -#endif - -// Disable warning C4251: : needs to have dll-interface to -// be used by... -#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) -#pragma warning(push) -#pragma warning(disable : 4251) -#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) - -/** \brief JSON (JavaScript Object Notation). - */ -namespace Json { - -/** Base class for all exceptions we throw. - * - * We use nothing but these internally. Of course, STL can throw others. - */ -class JSON_API Exception : public std::exception { -public: - Exception(std::string const& msg); - virtual ~Exception() throw(); - virtual char const* what() const throw(); -protected: - std::string const msg_; -}; - -/** Exceptions which the user cannot easily avoid. - * - * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input - * - * \remark derived from Json::Exception - */ -class JSON_API RuntimeError : public Exception { -public: - RuntimeError(std::string const& msg); -}; - -/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros. - * - * These are precondition-violations (user bugs) and internal errors (our bugs). - * - * \remark derived from Json::Exception - */ -class JSON_API LogicError : public Exception { -public: - LogicError(std::string const& msg); -}; - -/// used internally -void throwRuntimeError(std::string const& msg); -/// used internally -void throwLogicError(std::string const& msg); - -/** \brief Type of the value held by a Value object. - */ -enum ValueType { - nullValue = 0, ///< 'null' value - intValue, ///< signed integer value - uintValue, ///< unsigned integer value - realValue, ///< double value - stringValue, ///< UTF-8 string value - booleanValue, ///< bool value - arrayValue, ///< array value (ordered list) - objectValue ///< object value (collection of name/value pairs). -}; - -enum CommentPlacement { - commentBefore = 0, ///< a comment placed on the line before a value - commentAfterOnSameLine, ///< a comment just after a value on the same line - commentAfter, ///< a comment on the line after a value (only make sense for - /// root value) - numberOfCommentPlacement -}; - -//# ifdef JSON_USE_CPPTL -// typedef CppTL::AnyEnumerator EnumMemberNames; -// typedef CppTL::AnyEnumerator EnumValues; -//# endif - -/** \brief Lightweight wrapper to tag static string. - * - * Value constructor and objectValue member assignement takes advantage of the - * StaticString and avoid the cost of string duplication when storing the - * string or the member name. - * - * Example of usage: - * \code - * Json::Value aValue( StaticString("some text") ); - * Json::Value object; - * static const StaticString code("code"); - * object[code] = 1234; - * \endcode - */ -class JSON_API StaticString { -public: - explicit StaticString(const char* czstring) : c_str_(czstring) {} - - operator const char*() const { return c_str_; } - - const char* c_str() const { return c_str_; } - -private: - const char* c_str_; -}; - -/** \brief Represents a JSON value. - * - * This class is a discriminated union wrapper that can represents a: - * - signed integer [range: Value::minInt - Value::maxInt] - * - unsigned integer (range: 0 - Value::maxUInt) - * - double - * - UTF-8 string - * - boolean - * - 'null' - * - an ordered list of Value - * - collection of name/value pairs (javascript object) - * - * The type of the held value is represented by a #ValueType and - * can be obtained using type(). - * - * Values of an #objectValue or #arrayValue can be accessed using operator[]() - * methods. - * Non-const methods will automatically create the a #nullValue element - * if it does not exist. - * The sequence of an #arrayValue will be automatically resized and initialized - * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue. - * - * The get() methods can be used to obtain default value in the case the - * required element does not exist. - * - * It is possible to iterate over the list of a #objectValue values using - * the getMemberNames() method. - * - * \note #Value string-length fit in size_t, but keys must be < 2^30. - * (The reason is an implementation detail.) A #CharReader will raise an - * exception if a bound is exceeded to avoid security holes in your app, - * but the Value API does *not* check bounds. That is the responsibility - * of the caller. - */ -class JSON_API Value { - friend class ValueIteratorBase; -public: - typedef std::vector Members; - typedef ValueIterator iterator; - typedef ValueConstIterator const_iterator; - typedef Json::UInt UInt; - typedef Json::Int Int; -#if defined(JSON_HAS_INT64) - typedef Json::UInt64 UInt64; - typedef Json::Int64 Int64; -#endif // defined(JSON_HAS_INT64) - typedef Json::LargestInt LargestInt; - typedef Json::LargestUInt LargestUInt; - typedef Json::ArrayIndex ArrayIndex; - - static const Value& null; ///< We regret this reference to a global instance; prefer the simpler Value(). - static const Value& nullRef; ///< just a kludge for binary-compatibility; same as null - /// Minimum signed integer value that can be stored in a Json::Value. - static const LargestInt minLargestInt; - /// Maximum signed integer value that can be stored in a Json::Value. - static const LargestInt maxLargestInt; - /// Maximum unsigned integer value that can be stored in a Json::Value. - static const LargestUInt maxLargestUInt; - - /// Minimum signed int value that can be stored in a Json::Value. - static const Int minInt; - /// Maximum signed int value that can be stored in a Json::Value. - static const Int maxInt; - /// Maximum unsigned int value that can be stored in a Json::Value. - static const UInt maxUInt; - -#if defined(JSON_HAS_INT64) - /// Minimum signed 64 bits int value that can be stored in a Json::Value. - static const Int64 minInt64; - /// Maximum signed 64 bits int value that can be stored in a Json::Value. - static const Int64 maxInt64; - /// Maximum unsigned 64 bits int value that can be stored in a Json::Value. - static const UInt64 maxUInt64; -#endif // defined(JSON_HAS_INT64) - -private: -#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION - class CZString { - public: - enum DuplicationPolicy { - noDuplication = 0, - duplicate, - duplicateOnCopy - }; - CZString(ArrayIndex index); - CZString(char const* str, unsigned length, DuplicationPolicy allocate); - CZString(CZString const& other); - ~CZString(); - CZString& operator=(CZString other); - bool operator<(CZString const& other) const; - bool operator==(CZString const& other) const; - ArrayIndex index() const; - //const char* c_str() const; ///< \deprecated - char const* data() const; - unsigned length() const; - bool isStaticString() const; - - private: - void swap(CZString& other); - - struct StringStorage { - unsigned policy_: 2; - unsigned length_: 30; // 1GB max - }; - - char const* cstr_; // actually, a prefixed string, unless policy is noDup - union { - ArrayIndex index_; - StringStorage storage_; - }; - }; - -public: -#ifndef JSON_USE_CPPTL_SMALLMAP - typedef std::map ObjectValues; -#else - typedef CppTL::SmallMap ObjectValues; -#endif // ifndef JSON_USE_CPPTL_SMALLMAP -#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION - -public: - /** \brief Create a default Value of the given type. - - This is a very useful constructor. - To create an empty array, pass arrayValue. - To create an empty object, pass objectValue. - Another Value can then be set to this one by assignment. -This is useful since clear() and resize() will not alter types. - - Examples: -\code -Json::Value null_value; // null -Json::Value arr_value(Json::arrayValue); // [] -Json::Value obj_value(Json::objectValue); // {} -\endcode - */ - Value(ValueType type = nullValue); - Value(Int value); - Value(UInt value); -#if defined(JSON_HAS_INT64) - Value(Int64 value); - Value(UInt64 value); -#endif // if defined(JSON_HAS_INT64) - Value(double value); - Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.) - Value(const char* begin, const char* end); ///< Copy all, incl zeroes. - /** \brief Constructs a value from a static string. - - * Like other value string constructor but do not duplicate the string for - * internal storage. The given string must remain alive after the call to this - * constructor. - * \note This works only for null-terminated strings. (We cannot change the - * size of this class, so we have nowhere to store the length, - * which might be computed later for various operations.) - * - * Example of usage: - * \code - * static StaticString foo("some text"); - * Json::Value aValue(foo); - * \endcode - */ - Value(const StaticString& value); - Value(const std::string& value); ///< Copy data() til size(). Embedded zeroes too. -#ifdef JSON_USE_CPPTL - Value(const CppTL::ConstString& value); -#endif - Value(bool value); - /// Deep copy. - Value(const Value& other); - ~Value(); - - /// Deep copy, then swap(other). - /// \note Over-write existing comments. To preserve comments, use #swapPayload(). - Value& operator=(Value other); - /// Swap everything. - void swap(Value& other); - /// Swap values but leave comments and source offsets in place. - void swapPayload(Value& other); - - ValueType type() const; - - /// Compare payload only, not comments etc. - bool operator<(const Value& other) const; - bool operator<=(const Value& other) const; - bool operator>=(const Value& other) const; - bool operator>(const Value& other) const; - bool operator==(const Value& other) const; - bool operator!=(const Value& other) const; - int compare(const Value& other) const; - - const char* asCString() const; ///< Embedded zeroes could cause you trouble! - std::string asString() const; ///< Embedded zeroes are possible. - /** Get raw char* of string-value. - * \return false if !string. (Seg-fault if str or end are NULL.) - */ - bool getString( - char const** begin, char const** end) const; -#ifdef JSON_USE_CPPTL - CppTL::ConstString asConstString() const; -#endif - Int asInt() const; - UInt asUInt() const; -#if defined(JSON_HAS_INT64) - Int64 asInt64() const; - UInt64 asUInt64() const; -#endif // if defined(JSON_HAS_INT64) - LargestInt asLargestInt() const; - LargestUInt asLargestUInt() const; - float asFloat() const; - double asDouble() const; - bool asBool() const; - - bool isNull() const; - bool isBool() const; - bool isInt() const; - bool isInt64() const; - bool isUInt() const; - bool isUInt64() const; - bool isIntegral() const; - bool isDouble() const; - bool isNumeric() const; - bool isString() const; - bool isArray() const; - bool isObject() const; - - bool isConvertibleTo(ValueType other) const; - - /// Number of values in array or object - ArrayIndex size() const; - - /// \brief Return true if empty array, empty object, or null; - /// otherwise, false. - bool empty() const; - - /// Return isNull() - bool operator!() const; - - /// Remove all object members and array elements. - /// \pre type() is arrayValue, objectValue, or nullValue - /// \post type() is unchanged - void clear(); - - /// Resize the array to size elements. - /// New elements are initialized to null. - /// May only be called on nullValue or arrayValue. - /// \pre type() is arrayValue or nullValue - /// \post type() is arrayValue - void resize(ArrayIndex size); - - /// Access an array element (zero based index ). - /// If the array contains less than index element, then null value are - /// inserted - /// in the array so that its size is index+1. - /// (You may need to say 'value[0u]' to get your compiler to distinguish - /// this from the operator[] which takes a string.) - Value& operator[](ArrayIndex index); - - /// Access an array element (zero based index ). - /// If the array contains less than index element, then null value are - /// inserted - /// in the array so that its size is index+1. - /// (You may need to say 'value[0u]' to get your compiler to distinguish - /// this from the operator[] which takes a string.) - Value& operator[](int index); - - /// Access an array element (zero based index ) - /// (You may need to say 'value[0u]' to get your compiler to distinguish - /// this from the operator[] which takes a string.) - const Value& operator[](ArrayIndex index) const; - - /// Access an array element (zero based index ) - /// (You may need to say 'value[0u]' to get your compiler to distinguish - /// this from the operator[] which takes a string.) - const Value& operator[](int index) const; - - /// If the array contains at least index+1 elements, returns the element - /// value, - /// otherwise returns defaultValue. - Value get(ArrayIndex index, const Value& defaultValue) const; - /// Return true if index < size(). - bool isValidIndex(ArrayIndex index) const; - /// \brief Append value to array at the end. - /// - /// Equivalent to jsonvalue[jsonvalue.size()] = value; - Value& append(const Value& value); - - /// Access an object value by name, create a null member if it does not exist. - /// \note Because of our implementation, keys are limited to 2^30 -1 chars. - /// Exceeding that will cause an exception. - Value& operator[](const char* key); - /// Access an object value by name, returns null if there is no member with - /// that name. - const Value& operator[](const char* key) const; - /// Access an object value by name, create a null member if it does not exist. - /// \param key may contain embedded nulls. - Value& operator[](const std::string& key); - /// Access an object value by name, returns null if there is no member with - /// that name. - /// \param key may contain embedded nulls. - const Value& operator[](const std::string& key) const; - /** \brief Access an object value by name, create a null member if it does not - exist. - - * If the object has no entry for that name, then the member name used to store - * the new entry is not duplicated. - * Example of use: - * \code - * Json::Value object; - * static const StaticString code("code"); - * object[code] = 1234; - * \endcode - */ - Value& operator[](const StaticString& key); -#ifdef JSON_USE_CPPTL - /// Access an object value by name, create a null member if it does not exist. - Value& operator[](const CppTL::ConstString& key); - /// Access an object value by name, returns null if there is no member with - /// that name. - const Value& operator[](const CppTL::ConstString& key) const; -#endif - /// Return the member named key if it exist, defaultValue otherwise. - /// \note deep copy - Value get(const char* key, const Value& defaultValue) const; - /// Return the member named key if it exist, defaultValue otherwise. - /// \note deep copy - /// \note key may contain embedded nulls. - Value get(const char* begin, const char* end, const Value& defaultValue) const; - /// Return the member named key if it exist, defaultValue otherwise. - /// \note deep copy - /// \param key may contain embedded nulls. - Value get(const std::string& key, const Value& defaultValue) const; -#ifdef JSON_USE_CPPTL - /// Return the member named key if it exist, defaultValue otherwise. - /// \note deep copy - Value get(const CppTL::ConstString& key, const Value& defaultValue) const; -#endif - /// Most general and efficient version of isMember()const, get()const, - /// and operator[]const - /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30 - Value const* find(char const* begin, char const* end) const; - /// Most general and efficient version of object-mutators. - /// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30 - /// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue. - Value const* demand(char const* begin, char const* end); - /// \brief Remove and return the named member. - /// - /// Do nothing if it did not exist. - /// \return the removed Value, or null. - /// \pre type() is objectValue or nullValue - /// \post type() is unchanged - /// \deprecated - Value removeMember(const char* key); - /// Same as removeMember(const char*) - /// \param key may contain embedded nulls. - /// \deprecated - Value removeMember(const std::string& key); - /// Same as removeMember(const char* begin, const char* end, Value* removed), - /// but 'key' is null-terminated. - bool removeMember(const char* key, Value* removed); - /** \brief Remove the named map member. - - Update 'removed' iff removed. - \param key may contain embedded nulls. - \return true iff removed (no exceptions) - */ - bool removeMember(std::string const& key, Value* removed); - /// Same as removeMember(std::string const& key, Value* removed) - bool removeMember(const char* begin, const char* end, Value* removed); - /** \brief Remove the indexed array element. - - O(n) expensive operations. - Update 'removed' iff removed. - \return true iff removed (no exceptions) - */ - bool removeIndex(ArrayIndex i, Value* removed); - - /// Return true if the object has a member named key. - /// \note 'key' must be null-terminated. - bool isMember(const char* key) const; - /// Return true if the object has a member named key. - /// \param key may contain embedded nulls. - bool isMember(const std::string& key) const; - /// Same as isMember(std::string const& key)const - bool isMember(const char* begin, const char* end) const; -#ifdef JSON_USE_CPPTL - /// Return true if the object has a member named key. - bool isMember(const CppTL::ConstString& key) const; -#endif - - /// \brief Return a list of the member names. - /// - /// If null, return an empty list. - /// \pre type() is objectValue or nullValue - /// \post if type() was nullValue, it remains nullValue - Members getMemberNames() const; - - //# ifdef JSON_USE_CPPTL - // EnumMemberNames enumMemberNames() const; - // EnumValues enumValues() const; - //# endif - - /// \deprecated Always pass len. - JSONCPP_DEPRECATED("Use setComment(std::string const&) instead.") - void setComment(const char* comment, CommentPlacement placement); - /// Comments must be //... or /* ... */ - void setComment(const char* comment, size_t len, CommentPlacement placement); - /// Comments must be //... or /* ... */ - void setComment(const std::string& comment, CommentPlacement placement); - bool hasComment(CommentPlacement placement) const; - /// Include delimiters and embedded newlines. - std::string getComment(CommentPlacement placement) const; - - std::string toStyledString() const; - - const_iterator begin() const; - const_iterator end() const; - - iterator begin(); - iterator end(); - - // Accessors for the [start, limit) range of bytes within the JSON text from - // which this value was parsed, if any. - void setOffsetStart(size_t start); - void setOffsetLimit(size_t limit); - size_t getOffsetStart() const; - size_t getOffsetLimit() const; - -private: - void initBasic(ValueType type, bool allocated = false); - - Value& resolveReference(const char* key); - Value& resolveReference(const char* key, const char* end); - - struct CommentInfo { - CommentInfo(); - ~CommentInfo(); - - void setComment(const char* text, size_t len); - - char* comment_; - }; - - // struct MemberNamesTransform - //{ - // typedef const char *result_type; - // const char *operator()( const CZString &name ) const - // { - // return name.c_str(); - // } - //}; - - union ValueHolder { - LargestInt int_; - LargestUInt uint_; - double real_; - bool bool_; - char* string_; // actually ptr to unsigned, followed by str, unless !allocated_ - ObjectValues* map_; - } value_; - ValueType type_ : 8; - unsigned int allocated_ : 1; // Notes: if declared as bool, bitfield is useless. - // If not allocated_, string_ must be null-terminated. - CommentInfo* comments_; - - // [start, limit) byte offsets in the source JSON text from which this Value - // was extracted. - size_t start_; - size_t limit_; -}; - -/** \brief Experimental and untested: represents an element of the "path" to - * access a node. - */ -class JSON_API PathArgument { -public: - friend class Path; - - PathArgument(); - PathArgument(ArrayIndex index); - PathArgument(const char* key); - PathArgument(const std::string& key); - -private: - enum Kind { - kindNone = 0, - kindIndex, - kindKey - }; - std::string key_; - ArrayIndex index_; - Kind kind_; -}; - -/** \brief Experimental and untested: represents a "path" to access a node. - * - * Syntax: - * - "." => root node - * - ".[n]" => elements at index 'n' of root node (an array value) - * - ".name" => member named 'name' of root node (an object value) - * - ".name1.name2.name3" - * - ".[0][1][2].name1[3]" - * - ".%" => member name is provided as parameter - * - ".[%]" => index is provied as parameter - */ -class JSON_API Path { -public: - Path(const std::string& path, - const PathArgument& a1 = PathArgument(), - const PathArgument& a2 = PathArgument(), - const PathArgument& a3 = PathArgument(), - const PathArgument& a4 = PathArgument(), - const PathArgument& a5 = PathArgument()); - - const Value& resolve(const Value& root) const; - Value resolve(const Value& root, const Value& defaultValue) const; - /// Creates the "path" to access the specified node and returns a reference on - /// the node. - Value& make(Value& root) const; - -private: - typedef std::vector InArgs; - typedef std::vector Args; - - void makePath(const std::string& path, const InArgs& in); - void addPathInArg(const std::string& path, - const InArgs& in, - InArgs::const_iterator& itInArg, - PathArgument::Kind kind); - void invalidPath(const std::string& path, int location); - - Args args_; -}; - -/** \brief base class for Value iterators. - * - */ -class JSON_API ValueIteratorBase { -public: - typedef std::bidirectional_iterator_tag iterator_category; - typedef unsigned int size_t; - typedef int difference_type; - typedef ValueIteratorBase SelfType; - - bool operator==(const SelfType& other) const { return isEqual(other); } - - bool operator!=(const SelfType& other) const { return !isEqual(other); } - - difference_type operator-(const SelfType& other) const { - return other.computeDistance(*this); - } - - /// Return either the index or the member name of the referenced value as a - /// Value. - Value key() const; - - /// Return the index of the referenced Value, or -1 if it is not an arrayValue. - UInt index() const; - - /// Return the member name of the referenced Value, or "" if it is not an - /// objectValue. - /// \note Avoid `c_str()` on result, as embedded zeroes are possible. - std::string name() const; - - /// Return the member name of the referenced Value. "" if it is not an - /// objectValue. - /// \deprecated This cannot be used for UTF-8 strings, since there can be embedded nulls. - JSONCPP_DEPRECATED("Use `key = name();` instead.") - char const* memberName() const; - /// Return the member name of the referenced Value, or NULL if it is not an - /// objectValue. - /// \note Better version than memberName(). Allows embedded nulls. - char const* memberName(char const** end) const; - -protected: - Value& deref() const; - - void increment(); - - void decrement(); - - difference_type computeDistance(const SelfType& other) const; - - bool isEqual(const SelfType& other) const; - - void copy(const SelfType& other); - -private: - Value::ObjectValues::iterator current_; - // Indicates that iterator is for a null value. - bool isNull_; - -public: - // For some reason, BORLAND needs these at the end, rather - // than earlier. No idea why. - ValueIteratorBase(); - explicit ValueIteratorBase(const Value::ObjectValues::iterator& current); -}; - -/** \brief const iterator for object and array value. - * - */ -class JSON_API ValueConstIterator : public ValueIteratorBase { - friend class Value; - -public: - typedef const Value value_type; - //typedef unsigned int size_t; - //typedef int difference_type; - typedef const Value& reference; - typedef const Value* pointer; - typedef ValueConstIterator SelfType; - - ValueConstIterator(); - -private: -/*! \internal Use by Value to create an iterator. - */ - explicit ValueConstIterator(const Value::ObjectValues::iterator& current); -public: - SelfType& operator=(const ValueIteratorBase& other); - - SelfType operator++(int) { - SelfType temp(*this); - ++*this; - return temp; - } - - SelfType operator--(int) { - SelfType temp(*this); - --*this; - return temp; - } - - SelfType& operator--() { - decrement(); - return *this; - } - - SelfType& operator++() { - increment(); - return *this; - } - - reference operator*() const { return deref(); } - - pointer operator->() const { return &deref(); } -}; - -/** \brief Iterator for object and array value. - */ -class JSON_API ValueIterator : public ValueIteratorBase { - friend class Value; - -public: - typedef Value value_type; - typedef unsigned int size_t; - typedef int difference_type; - typedef Value& reference; - typedef Value* pointer; - typedef ValueIterator SelfType; - - ValueIterator(); - ValueIterator(const ValueConstIterator& other); - ValueIterator(const ValueIterator& other); - -private: -/*! \internal Use by Value to create an iterator. - */ - explicit ValueIterator(const Value::ObjectValues::iterator& current); -public: - SelfType& operator=(const SelfType& other); - - SelfType operator++(int) { - SelfType temp(*this); - ++*this; - return temp; - } - - SelfType operator--(int) { - SelfType temp(*this); - --*this; - return temp; - } - - SelfType& operator--() { - decrement(); - return *this; - } - - SelfType& operator++() { - increment(); - return *this; - } - - reference operator*() const { return deref(); } - - pointer operator->() const { return &deref(); } -}; - -} // namespace Json - - -namespace std { -/// Specialize std::swap() for Json::Value. -template<> -inline void swap(Json::Value& a, Json::Value& b) { a.swap(b); } -} - - -#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) -#pragma warning(pop) -#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) - -#endif // CPPTL_JSON_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: include/json/value.h -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: include/json/reader.h -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#ifndef CPPTL_JSON_READER_H_INCLUDED -#define CPPTL_JSON_READER_H_INCLUDED - -#if !defined(JSON_IS_AMALGAMATION) -#include "features.h" -#include "value.h" -#endif // if !defined(JSON_IS_AMALGAMATION) -#include -#include -#include -#include -#include - -// Disable warning C4251: : needs to have dll-interface to -// be used by... -#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) -#pragma warning(push) -#pragma warning(disable : 4251) -#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) - -namespace Json { - -/** \brief Unserialize a JSON document into a - *Value. - * - * \deprecated Use CharReader and CharReaderBuilder. - */ -class JSON_API Reader { -public: - typedef char Char; - typedef const Char* Location; - - /** \brief An error tagged with where in the JSON text it was encountered. - * - * The offsets give the [start, limit) range of bytes within the text. Note - * that this is bytes, not codepoints. - * - */ - struct StructuredError { - size_t offset_start; - size_t offset_limit; - std::string message; - }; - - /** \brief Constructs a Reader allowing all features - * for parsing. - */ - Reader(); - - /** \brief Constructs a Reader allowing the specified feature set - * for parsing. - */ - Reader(const Features& features); - - /** \brief Read a Value from a JSON - * document. - * \param document UTF-8 encoded string containing the document to read. - * \param root [out] Contains the root value of the document if it was - * successfully parsed. - * \param collectComments \c true to collect comment and allow writing them - * back during - * serialization, \c false to discard comments. - * This parameter is ignored if - * Features::allowComments_ - * is \c false. - * \return \c true if the document was successfully parsed, \c false if an - * error occurred. - */ - bool - parse(const std::string& document, Value& root, bool collectComments = true); - - /** \brief Read a Value from a JSON - document. - * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the - document to read. - * \param endDoc Pointer on the end of the UTF-8 encoded string of the - document to read. - * Must be >= beginDoc. - * \param root [out] Contains the root value of the document if it was - * successfully parsed. - * \param collectComments \c true to collect comment and allow writing them - back during - * serialization, \c false to discard comments. - * This parameter is ignored if - Features::allowComments_ - * is \c false. - * \return \c true if the document was successfully parsed, \c false if an - error occurred. - */ - bool parse(const char* beginDoc, - const char* endDoc, - Value& root, - bool collectComments = true); - - /// \brief Parse from input stream. - /// \see Json::operator>>(std::istream&, Json::Value&). - bool parse(std::istream& is, Value& root, bool collectComments = true); - - /** \brief Returns a user friendly string that list errors in the parsed - * document. - * \return Formatted error message with the list of errors with their location - * in - * the parsed document. An empty string is returned if no error - * occurred - * during parsing. - * \deprecated Use getFormattedErrorMessages() instead (typo fix). - */ - JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.") - std::string getFormatedErrorMessages() const; - - /** \brief Returns a user friendly string that list errors in the parsed - * document. - * \return Formatted error message with the list of errors with their location - * in - * the parsed document. An empty string is returned if no error - * occurred - * during parsing. - */ - std::string getFormattedErrorMessages() const; - - /** \brief Returns a vector of structured erros encounted while parsing. - * \return A (possibly empty) vector of StructuredError objects. Currently - * only one error can be returned, but the caller should tolerate - * multiple - * errors. This can occur if the parser recovers from a non-fatal - * parse error and then encounters additional errors. - */ - std::vector getStructuredErrors() const; - - /** \brief Add a semantic error message. - * \param value JSON Value location associated with the error - * \param message The error message. - * \return \c true if the error was successfully added, \c false if the - * Value offset exceeds the document size. - */ - bool pushError(const Value& value, const std::string& message); - - /** \brief Add a semantic error message with extra context. - * \param value JSON Value location associated with the error - * \param message The error message. - * \param extra Additional JSON Value location to contextualize the error - * \return \c true if the error was successfully added, \c false if either - * Value offset exceeds the document size. - */ - bool pushError(const Value& value, const std::string& message, const Value& extra); - - /** \brief Return whether there are any errors. - * \return \c true if there are no errors to report \c false if - * errors have occurred. - */ - bool good() const; - -private: - enum TokenType { - tokenEndOfStream = 0, - tokenObjectBegin, - tokenObjectEnd, - tokenArrayBegin, - tokenArrayEnd, - tokenString, - tokenNumber, - tokenTrue, - tokenFalse, - tokenNull, - tokenArraySeparator, - tokenMemberSeparator, - tokenComment, - tokenError - }; - - class Token { - public: - TokenType type_; - Location start_; - Location end_; - }; - - class ErrorInfo { - public: - Token token_; - std::string message_; - Location extra_; - }; - - typedef std::deque Errors; - - bool readToken(Token& token); - void skipSpaces(); - bool match(Location pattern, int patternLength); - bool readComment(); - bool readCStyleComment(); - bool readCppStyleComment(); - bool readString(); - void readNumber(); - bool readValue(); - bool readObject(Token& token); - bool readArray(Token& token); - bool decodeNumber(Token& token); - bool decodeNumber(Token& token, Value& decoded); - bool decodeString(Token& token); - bool decodeString(Token& token, std::string& decoded); - bool decodeDouble(Token& token); - bool decodeDouble(Token& token, Value& decoded); - bool decodeUnicodeCodePoint(Token& token, - Location& current, - Location end, - unsigned int& unicode); - bool decodeUnicodeEscapeSequence(Token& token, - Location& current, - Location end, - unsigned int& unicode); - bool addError(const std::string& message, Token& token, Location extra = 0); - bool recoverFromError(TokenType skipUntilToken); - bool addErrorAndRecover(const std::string& message, - Token& token, - TokenType skipUntilToken); - void skipUntilSpace(); - Value& currentValue(); - Char getNextChar(); - void - getLocationLineAndColumn(Location location, int& line, int& column) const; - std::string getLocationLineAndColumn(Location location) const; - void addComment(Location begin, Location end, CommentPlacement placement); - void skipCommentTokens(Token& token); - - typedef std::stack Nodes; - Nodes nodes_; - Errors errors_; - std::string document_; - Location begin_; - Location end_; - Location current_; - Location lastValueEnd_; - Value* lastValue_; - std::string commentsBefore_; - Features features_; - bool collectComments_; -}; // Reader - -/** Interface for reading JSON from a char array. - */ -class JSON_API CharReader { -public: - virtual ~CharReader() {} - /** \brief Read a Value from a JSON - document. - * The document must be a UTF-8 encoded string containing the document to read. - * - * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the - document to read. - * \param endDoc Pointer on the end of the UTF-8 encoded string of the - document to read. - * Must be >= beginDoc. - * \param root [out] Contains the root value of the document if it was - * successfully parsed. - * \param errs [out] Formatted error messages (if not NULL) - * a user friendly string that lists errors in the parsed - * document. - * \return \c true if the document was successfully parsed, \c false if an - error occurred. - */ - virtual bool parse( - char const* beginDoc, char const* endDoc, - Value* root, std::string* errs) = 0; - - class Factory { - public: - virtual ~Factory() {} - /** \brief Allocate a CharReader via operator new(). - * \throw std::exception if something goes wrong (e.g. invalid settings) - */ - virtual CharReader* newCharReader() const = 0; - }; // Factory -}; // CharReader - -/** \brief Build a CharReader implementation. - -Usage: -\code - using namespace Json; - CharReaderBuilder builder; - builder["collectComments"] = false; - Value value; - std::string errs; - bool ok = parseFromStream(builder, std::cin, &value, &errs); -\endcode -*/ -class JSON_API CharReaderBuilder : public CharReader::Factory { -public: - // Note: We use a Json::Value so that we can add data-members to this class - // without a major version bump. - /** Configuration of this builder. - These are case-sensitive. - Available settings (case-sensitive): - - `"collectComments": false or true` - - true to collect comment and allow writing them - back during serialization, false to discard comments. - This parameter is ignored if allowComments is false. - - `"allowComments": false or true` - - true if comments are allowed. - - `"strictRoot": false or true` - - true if root must be either an array or an object value - - `"allowDroppedNullPlaceholders": false or true` - - true if dropped null placeholders are allowed. (See StreamWriterBuilder.) - - `"allowNumericKeys": false or true` - - true if numeric object keys are allowed. - - `"allowSingleQuotes": false or true` - - true if '' are allowed for strings (both keys and values) - - `"stackLimit": integer` - - Exceeding stackLimit (recursive depth of `readValue()`) will - cause an exception. - - This is a security issue (seg-faults caused by deeply nested JSON), - so the default is low. - - `"failIfExtra": false or true` - - If true, `parse()` returns false when extra non-whitespace trails - the JSON value in the input string. - - `"rejectDupKeys": false or true` - - If true, `parse()` returns false when a key is duplicated within an object. - - You can examine 'settings_` yourself - to see the defaults. You can also write and read them just like any - JSON Value. - \sa setDefaults() - */ - Json::Value settings_; - - CharReaderBuilder(); - virtual ~CharReaderBuilder(); - - virtual CharReader* newCharReader() const; - - /** \return true if 'settings' are legal and consistent; - * otherwise, indicate bad settings via 'invalid'. - */ - bool validate(Json::Value* invalid) const; - - /** A simple way to update a specific setting. - */ - Value& operator[](std::string key); - - /** Called by ctor, but you can use this to reset settings_. - * \pre 'settings' != NULL (but Json::null is fine) - * \remark Defaults: - * \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults - */ - static void setDefaults(Json::Value* settings); - /** Same as old Features::strictMode(). - * \pre 'settings' != NULL (but Json::null is fine) - * \remark Defaults: - * \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode - */ - static void strictMode(Json::Value* settings); -}; - -/** Consume entire stream and use its begin/end. - * Someday we might have a real StreamReader, but for now this - * is convenient. - */ -bool JSON_API parseFromStream( - CharReader::Factory const&, - std::istream&, - Value* root, std::string* errs); - -/** \brief Read from 'sin' into 'root'. - - Always keep comments from the input JSON. - - This can be used to read a file into a particular sub-object. - For example: - \code - Json::Value root; - cin >> root["dir"]["file"]; - cout << root; - \endcode - Result: - \verbatim - { - "dir": { - "file": { - // The input stream JSON would be nested here. - } - } - } - \endverbatim - \throw std::exception on parse error. - \see Json::operator<<() -*/ -JSON_API std::istream& operator>>(std::istream&, Value&); - -} // namespace Json - -#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) -#pragma warning(pop) -#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) - -#endif // CPPTL_JSON_READER_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: include/json/reader.h -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: include/json/writer.h -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#ifndef JSON_WRITER_H_INCLUDED -#define JSON_WRITER_H_INCLUDED - -#if !defined(JSON_IS_AMALGAMATION) -#include "value.h" -#endif // if !defined(JSON_IS_AMALGAMATION) -#include -#include -#include - -// Disable warning C4251: : needs to have dll-interface to -// be used by... -#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) -#pragma warning(push) -#pragma warning(disable : 4251) -#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) - -namespace Json { - -class Value; - -/** - -Usage: -\code - using namespace Json; - void writeToStdout(StreamWriter::Factory const& factory, Value const& value) { - std::unique_ptr const writer( - factory.newStreamWriter()); - writer->write(value, &std::cout); - std::cout << std::endl; // add lf and flush - } -\endcode -*/ -class JSON_API StreamWriter { -protected: - std::ostream* sout_; // not owned; will not delete -public: - StreamWriter(); - virtual ~StreamWriter(); - /** Write Value into document as configured in sub-class. - Do not take ownership of sout, but maintain a reference during function. - \pre sout != NULL - \return zero on success (For now, we always return zero, so check the stream instead.) - \throw std::exception possibly, depending on configuration - */ - virtual int write(Value const& root, std::ostream* sout) = 0; - - /** \brief A simple abstract factory. - */ - class JSON_API Factory { - public: - virtual ~Factory(); - /** \brief Allocate a CharReader via operator new(). - * \throw std::exception if something goes wrong (e.g. invalid settings) - */ - virtual StreamWriter* newStreamWriter() const = 0; - }; // Factory -}; // StreamWriter - -/** \brief Write into stringstream, then return string, for convenience. - * A StreamWriter will be created from the factory, used, and then deleted. - */ -std::string JSON_API writeString(StreamWriter::Factory const& factory, Value const& root); - - -/** \brief Build a StreamWriter implementation. - -Usage: -\code - using namespace Json; - Value value = ...; - StreamWriterBuilder builder; - builder["commentStyle"] = "None"; - builder["indentation"] = " "; // or whatever you like - std::unique_ptr writer( - builder.newStreamWriter()); - writer->write(value, &std::cout); - std::cout << std::endl; // add lf and flush -\endcode -*/ -class JSON_API StreamWriterBuilder : public StreamWriter::Factory { -public: - // Note: We use a Json::Value so that we can add data-members to this class - // without a major version bump. - /** Configuration of this builder. - Available settings (case-sensitive): - - "commentStyle": "None" or "All" - - "indentation": "" - - "enableYAMLCompatibility": false or true - - slightly change the whitespace around colons - - "dropNullPlaceholders": false or true - - Drop the "null" string from the writer's output for nullValues. - Strictly speaking, this is not valid JSON. But when the output is being - fed to a browser's Javascript, it makes for smaller output and the - browser can handle the output just fine. - - You can examine 'settings_` yourself - to see the defaults. You can also write and read them just like any - JSON Value. - \sa setDefaults() - */ - Json::Value settings_; - - StreamWriterBuilder(); - virtual ~StreamWriterBuilder(); - - /** - * \throw std::exception if something goes wrong (e.g. invalid settings) - */ - virtual StreamWriter* newStreamWriter() const; - - /** \return true if 'settings' are legal and consistent; - * otherwise, indicate bad settings via 'invalid'. - */ - bool validate(Json::Value* invalid) const; - /** A simple way to update a specific setting. - */ - Value& operator[](std::string key); - - /** Called by ctor, but you can use this to reset settings_. - * \pre 'settings' != NULL (but Json::null is fine) - * \remark Defaults: - * \snippet src/lib_json/json_writer.cpp StreamWriterBuilderDefaults - */ - static void setDefaults(Json::Value* settings); -}; - -/** \brief Abstract class for writers. - * \deprecated Use StreamWriter. (And really, this is an implementation detail.) - */ -class JSON_API Writer { -public: - virtual ~Writer(); - - virtual std::string write(const Value& root) = 0; -}; - -/** \brief Outputs a Value in JSON format - *without formatting (not human friendly). - * - * The JSON document is written in a single line. It is not intended for 'human' - *consumption, - * but may be usefull to support feature such as RPC where bandwith is limited. - * \sa Reader, Value - * \deprecated Use StreamWriterBuilder. - */ -class JSON_API FastWriter : public Writer { - -public: - FastWriter(); - virtual ~FastWriter() {} - - void enableYAMLCompatibility(); - - /** \brief Drop the "null" string from the writer's output for nullValues. - * Strictly speaking, this is not valid JSON. But when the output is being - * fed to a browser's Javascript, it makes for smaller output and the - * browser can handle the output just fine. - */ - void dropNullPlaceholders(); - - void omitEndingLineFeed(); - -public: // overridden from Writer - virtual std::string write(const Value& root); - -private: - void writeValue(const Value& value); - - std::string document_; - bool yamlCompatiblityEnabled_; - bool dropNullPlaceholders_; - bool omitEndingLineFeed_; -}; - -/** \brief Writes a Value in JSON format in a - *human friendly way. - * - * The rules for line break and indent are as follow: - * - Object value: - * - if empty then print {} without indent and line break - * - if not empty the print '{', line break & indent, print one value per - *line - * and then unindent and line break and print '}'. - * - Array value: - * - if empty then print [] without indent and line break - * - if the array contains no object value, empty array or some other value - *types, - * and all the values fit on one lines, then print the array on a single - *line. - * - otherwise, it the values do not fit on one line, or the array contains - * object or non empty array, then print one value per line. - * - * If the Value have comments then they are outputed according to their - *#CommentPlacement. - * - * \sa Reader, Value, Value::setComment() - * \deprecated Use StreamWriterBuilder. - */ -class JSON_API StyledWriter : public Writer { -public: - StyledWriter(); - virtual ~StyledWriter() {} - -public: // overridden from Writer - /** \brief Serialize a Value in JSON format. - * \param root Value to serialize. - * \return String containing the JSON document that represents the root value. - */ - virtual std::string write(const Value& root); - -private: - void writeValue(const Value& value); - void writeArrayValue(const Value& value); - bool isMultineArray(const Value& value); - void pushValue(const std::string& value); - void writeIndent(); - void writeWithIndent(const std::string& value); - void indent(); - void unindent(); - void writeCommentBeforeValue(const Value& root); - void writeCommentAfterValueOnSameLine(const Value& root); - bool hasCommentForValue(const Value& value); - static std::string normalizeEOL(const std::string& text); - - typedef std::vector ChildValues; - - ChildValues childValues_; - std::string document_; - std::string indentString_; - int rightMargin_; - int indentSize_; - bool addChildValues_; -}; - -/** \brief Writes a Value in JSON format in a - human friendly way, - to a stream rather than to a string. - * - * The rules for line break and indent are as follow: - * - Object value: - * - if empty then print {} without indent and line break - * - if not empty the print '{', line break & indent, print one value per - line - * and then unindent and line break and print '}'. - * - Array value: - * - if empty then print [] without indent and line break - * - if the array contains no object value, empty array or some other value - types, - * and all the values fit on one lines, then print the array on a single - line. - * - otherwise, it the values do not fit on one line, or the array contains - * object or non empty array, then print one value per line. - * - * If the Value have comments then they are outputed according to their - #CommentPlacement. - * - * \param indentation Each level will be indented by this amount extra. - * \sa Reader, Value, Value::setComment() - * \deprecated Use StreamWriterBuilder. - */ -class JSON_API StyledStreamWriter { -public: - StyledStreamWriter(std::string indentation = "\t"); - ~StyledStreamWriter() {} - -public: - /** \brief Serialize a Value in JSON format. - * \param out Stream to write to. (Can be ostringstream, e.g.) - * \param root Value to serialize. - * \note There is no point in deriving from Writer, since write() should not - * return a value. - */ - void write(std::ostream& out, const Value& root); - -private: - void writeValue(const Value& value); - void writeArrayValue(const Value& value); - bool isMultineArray(const Value& value); - void pushValue(const std::string& value); - void writeIndent(); - void writeWithIndent(const std::string& value); - void indent(); - void unindent(); - void writeCommentBeforeValue(const Value& root); - void writeCommentAfterValueOnSameLine(const Value& root); - bool hasCommentForValue(const Value& value); - static std::string normalizeEOL(const std::string& text); - - typedef std::vector ChildValues; - - ChildValues childValues_; - std::ostream* document_; - std::string indentString_; - int rightMargin_; - std::string indentation_; - bool addChildValues_ : 1; - bool indented_ : 1; -}; - -#if defined(JSON_HAS_INT64) -std::string JSON_API valueToString(Int value); -std::string JSON_API valueToString(UInt value); -#endif // if defined(JSON_HAS_INT64) -std::string JSON_API valueToString(LargestInt value); -std::string JSON_API valueToString(LargestUInt value); -std::string JSON_API valueToString(double value); -std::string JSON_API valueToString(bool value); -std::string JSON_API valueToQuotedString(const char* value); - -/// \brief Output using the StyledStreamWriter. -/// \see Json::operator>>() -JSON_API std::ostream& operator<<(std::ostream&, const Value& root); - -} // namespace Json - -#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) -#pragma warning(pop) -#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) - -#endif // JSON_WRITER_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: include/json/writer.h -// ////////////////////////////////////////////////////////////////////// - - - - - - -// ////////////////////////////////////////////////////////////////////// -// Beginning of content of file: include/json/assertions.h -// ////////////////////////////////////////////////////////////////////// - -// Copyright 2007-2010 Baptiste Lepilleur -// Distributed under MIT license, or public domain if desired and -// recognized in your jurisdiction. -// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE - -#ifndef CPPTL_JSON_ASSERTIONS_H_INCLUDED -#define CPPTL_JSON_ASSERTIONS_H_INCLUDED - -#include -#include - -#if !defined(JSON_IS_AMALGAMATION) -#include "config.h" -#endif // if !defined(JSON_IS_AMALGAMATION) - -/** It should not be possible for a maliciously designed file to - * cause an abort() or seg-fault, so these macros are used only - * for pre-condition violations and internal logic errors. - */ -#if JSON_USE_EXCEPTION - -// @todo <= add detail about condition in exception -# define JSON_ASSERT(condition) \ - {if (!(condition)) {Json::throwLogicError( "assert json failed" );}} - -# define JSON_FAIL_MESSAGE(message) \ - { \ - std::ostringstream oss; oss << message; \ - Json::throwLogicError(oss.str()); \ - abort(); \ - } - -#else // JSON_USE_EXCEPTION - -# define JSON_ASSERT(condition) assert(condition) - -// The call to assert() will show the failure message in debug builds. In -// release builds we abort, for a core-dump or debugger. -# define JSON_FAIL_MESSAGE(message) \ - { \ - std::ostringstream oss; oss << message; \ - assert(false && oss.str().c_str()); \ - abort(); \ - } - - -#endif - -#define JSON_ASSERT_MESSAGE(condition, message) \ - if (!(condition)) { \ - JSON_FAIL_MESSAGE(message); \ - } - -#endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED - -// ////////////////////////////////////////////////////////////////////// -// End of content of file: include/json/assertions.h -// ////////////////////////////////////////////////////////////////////// - - - - - -#endif //ifndef JSON_AMALGATED_H_INCLUDED diff --git a/depends/libexpat b/depends/libexpat new file mode 160000 index 0000000000..e3ea446907 --- /dev/null +++ b/depends/libexpat @@ -0,0 +1 @@ +Subproject commit e3ea4469079702ddf352bb3333bf85130c5346c2 diff --git a/depends/libzip b/depends/libzip new file mode 160000 index 0000000000..011e45e125 --- /dev/null +++ b/depends/libzip @@ -0,0 +1 @@ +Subproject commit 011e45e125631cff73c0d6a5d19e0232dfc4df6f diff --git a/depends/lodepng/CMakeLists.txt b/depends/lodepng/CMakeLists.txt new file mode 100644 index 0000000000..41cf16864a --- /dev/null +++ b/depends/lodepng/CMakeLists.txt @@ -0,0 +1,3 @@ +project(dfhack-lodepng) +add_library(dfhack-lodepng STATIC EXCLUDE_FROM_ALL lodepng.cpp lodepng.h) +ide_folder(dfhack-lodepng "Depends") diff --git a/depends/lodepng/LICENSE b/depends/lodepng/LICENSE new file mode 100644 index 0000000000..a5fb0603d9 --- /dev/null +++ b/depends/lodepng/LICENSE @@ -0,0 +1,21 @@ +Copyright (c) 2005-2018 Lode Vandevenne + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any damages +arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + + 3. This notice may not be removed or altered from any source + distribution. + diff --git a/depends/lodepng/lodepng.cpp b/depends/lodepng/lodepng.cpp new file mode 100644 index 0000000000..51492b887f --- /dev/null +++ b/depends/lodepng/lodepng.cpp @@ -0,0 +1,6464 @@ +/* +LodePNG version 20201017 + +Copyright (c) 2005-2020 Lode Vandevenne + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any damages +arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + + 3. This notice may not be removed or altered from any source + distribution. +*/ + +/* +The manual and changelog are in the header file "lodepng.h" +Rename this file to lodepng.cpp to use it for C++, or to lodepng.c to use it for C. +*/ + +#include "lodepng.h" + +#ifdef LODEPNG_COMPILE_DISK +#include /* LONG_MAX */ +#include /* file handling */ +#endif /* LODEPNG_COMPILE_DISK */ + +#ifdef LODEPNG_COMPILE_ALLOCATORS +#include /* allocations */ +#endif /* LODEPNG_COMPILE_ALLOCATORS */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1310) /*Visual Studio: A few warning types are not desired here.*/ +#pragma warning( disable : 4244 ) /*implicit conversions: not warned by gcc -Wall -Wextra and requires too much casts*/ +#pragma warning( disable : 4996 ) /*VS does not like fopen, but fopen_s is not standard C so unusable here*/ +#endif /*_MSC_VER */ + +const char* LODEPNG_VERSION_STRING = "20201017"; + +/* +This source file is built up in the following large parts. The code sections +with the "LODEPNG_COMPILE_" #defines divide this up further in an intermixed way. +-Tools for C and common code for PNG and Zlib +-C Code for Zlib (huffman, deflate, ...) +-C Code for PNG (file format chunks, adam7, PNG filters, color conversions, ...) +-The C++ wrapper around all of the above +*/ + +/* ////////////////////////////////////////////////////////////////////////// */ +/* ////////////////////////////////////////////////////////////////////////// */ +/* // Tools for C, and common code for PNG and Zlib. // */ +/* ////////////////////////////////////////////////////////////////////////// */ +/* ////////////////////////////////////////////////////////////////////////// */ + +/*The malloc, realloc and free functions defined here with "lodepng_" in front +of the name, so that you can easily change them to others related to your +platform if needed. Everything else in the code calls these. Pass +-DLODEPNG_NO_COMPILE_ALLOCATORS to the compiler, or comment out +#define LODEPNG_COMPILE_ALLOCATORS in the header, to disable the ones here and +define them in your own project's source files without needing to change +lodepng source code. Don't forget to remove "static" if you copypaste them +from here.*/ + +#ifdef LODEPNG_COMPILE_ALLOCATORS +static void* lodepng_malloc(size_t size) { +#ifdef LODEPNG_MAX_ALLOC + if(size > LODEPNG_MAX_ALLOC) return 0; +#endif + return malloc(size); +} + +/* NOTE: when realloc returns NULL, it leaves the original memory untouched */ +static void* lodepng_realloc(void* ptr, size_t new_size) { +#ifdef LODEPNG_MAX_ALLOC + if(new_size > LODEPNG_MAX_ALLOC) return 0; +#endif + return realloc(ptr, new_size); +} + +static void lodepng_free(void* ptr) { + free(ptr); +} +#else /*LODEPNG_COMPILE_ALLOCATORS*/ +/* TODO: support giving additional void* payload to the custom allocators */ +void* lodepng_malloc(size_t size); +void* lodepng_realloc(void* ptr, size_t new_size); +void lodepng_free(void* ptr); +#endif /*LODEPNG_COMPILE_ALLOCATORS*/ + +/* convince the compiler to inline a function, for use when this measurably improves performance */ +/* inline is not available in C90, but use it when supported by the compiler */ +#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || (defined(__cplusplus) && (__cplusplus >= 199711L)) +#define LODEPNG_INLINE inline +#else +#define LODEPNG_INLINE /* not available */ +#endif + +/* restrict is not available in C90, but use it when supported by the compiler */ +#if (defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))) ||\ + (defined(_MSC_VER) && (_MSC_VER >= 1400)) || \ + (defined(__WATCOMC__) && (__WATCOMC__ >= 1250) && !defined(__cplusplus)) +#define LODEPNG_RESTRICT __restrict +#else +#define LODEPNG_RESTRICT /* not available */ +#endif + +/* Replacements for C library functions such as memcpy and strlen, to support platforms +where a full C library is not available. The compiler can recognize them and compile +to something as fast. */ + +static void lodepng_memcpy(void* LODEPNG_RESTRICT dst, + const void* LODEPNG_RESTRICT src, size_t size) { + size_t i; + for(i = 0; i < size; i++) ((char*)dst)[i] = ((const char*)src)[i]; +} + +static void lodepng_memset(void* LODEPNG_RESTRICT dst, + int value, size_t num) { + size_t i; + for(i = 0; i < num; i++) ((char*)dst)[i] = (char)value; +} + +/* does not check memory out of bounds, do not use on untrusted data */ +static size_t lodepng_strlen(const char* a) { + const char* orig = a; + /* avoid warning about unused function in case of disabled COMPILE... macros */ + (void)(&lodepng_strlen); + while(*a) a++; + return (size_t)(a - orig); +} + +#define LODEPNG_MAX(a, b) (((a) > (b)) ? (a) : (b)) +#define LODEPNG_MIN(a, b) (((a) < (b)) ? (a) : (b)) +#define LODEPNG_ABS(x) ((x) < 0 ? -(x) : (x)) + +#if defined(LODEPNG_COMPILE_PNG) || defined(LODEPNG_COMPILE_DECODER) +/* Safely check if adding two integers will overflow (no undefined +behavior, compiler removing the code, etc...) and output result. */ +static int lodepng_addofl(size_t a, size_t b, size_t* result) { + *result = a + b; /* Unsigned addition is well defined and safe in C90 */ + return *result < a; +} +#endif /*defined(LODEPNG_COMPILE_PNG) || defined(LODEPNG_COMPILE_DECODER)*/ + +#ifdef LODEPNG_COMPILE_DECODER +/* Safely check if multiplying two integers will overflow (no undefined +behavior, compiler removing the code, etc...) and output result. */ +static int lodepng_mulofl(size_t a, size_t b, size_t* result) { + *result = a * b; /* Unsigned multiplication is well defined and safe in C90 */ + return (a != 0 && *result / a != b); +} + +#ifdef LODEPNG_COMPILE_ZLIB +/* Safely check if a + b > c, even if overflow could happen. */ +static int lodepng_gtofl(size_t a, size_t b, size_t c) { + size_t d; + if(lodepng_addofl(a, b, &d)) return 1; + return d > c; +} +#endif /*LODEPNG_COMPILE_ZLIB*/ +#endif /*LODEPNG_COMPILE_DECODER*/ + + +/* +Often in case of an error a value is assigned to a variable and then it breaks +out of a loop (to go to the cleanup phase of a function). This macro does that. +It makes the error handling code shorter and more readable. + +Example: if(!uivector_resize(&lz77_encoded, datasize)) ERROR_BREAK(83); +*/ +#define CERROR_BREAK(errorvar, code){\ + errorvar = code;\ + break;\ +} + +/*version of CERROR_BREAK that assumes the common case where the error variable is named "error"*/ +#define ERROR_BREAK(code) CERROR_BREAK(error, code) + +/*Set error var to the error code, and return it.*/ +#define CERROR_RETURN_ERROR(errorvar, code){\ + errorvar = code;\ + return code;\ +} + +/*Try the code, if it returns error, also return the error.*/ +#define CERROR_TRY_RETURN(call){\ + unsigned error = call;\ + if(error) return error;\ +} + +/*Set error var to the error code, and return from the void function.*/ +#define CERROR_RETURN(errorvar, code){\ + errorvar = code;\ + return;\ +} + +/* +About uivector, ucvector and string: +-All of them wrap dynamic arrays or text strings in a similar way. +-LodePNG was originally written in C++. The vectors replace the std::vectors that were used in the C++ version. +-The string tools are made to avoid problems with compilers that declare things like strncat as deprecated. +-They're not used in the interface, only internally in this file as static functions. +-As with many other structs in this file, the init and cleanup functions serve as ctor and dtor. +*/ + +#ifdef LODEPNG_COMPILE_ZLIB +#ifdef LODEPNG_COMPILE_ENCODER +/*dynamic vector of unsigned ints*/ +typedef struct uivector { + unsigned* data; + size_t size; /*size in number of unsigned longs*/ + size_t allocsize; /*allocated size in bytes*/ +} uivector; + +static void uivector_cleanup(void* p) { + ((uivector*)p)->size = ((uivector*)p)->allocsize = 0; + lodepng_free(((uivector*)p)->data); + ((uivector*)p)->data = NULL; +} + +/*returns 1 if success, 0 if failure ==> nothing done*/ +static unsigned uivector_resize(uivector* p, size_t size) { + size_t allocsize = size * sizeof(unsigned); + if(allocsize > p->allocsize) { + size_t newsize = allocsize + (p->allocsize >> 1u); + void* data = lodepng_realloc(p->data, newsize); + if(data) { + p->allocsize = newsize; + p->data = (unsigned*)data; + } + else return 0; /*error: not enough memory*/ + } + p->size = size; + return 1; /*success*/ +} + +static void uivector_init(uivector* p) { + p->data = NULL; + p->size = p->allocsize = 0; +} + +/*returns 1 if success, 0 if failure ==> nothing done*/ +static unsigned uivector_push_back(uivector* p, unsigned c) { + if(!uivector_resize(p, p->size + 1)) return 0; + p->data[p->size - 1] = c; + return 1; +} +#endif /*LODEPNG_COMPILE_ENCODER*/ +#endif /*LODEPNG_COMPILE_ZLIB*/ + +/* /////////////////////////////////////////////////////////////////////////// */ + +/*dynamic vector of unsigned chars*/ +typedef struct ucvector { + unsigned char* data; + size_t size; /*used size*/ + size_t allocsize; /*allocated size*/ +} ucvector; + +/*returns 1 if success, 0 if failure ==> nothing done*/ +static unsigned ucvector_resize(ucvector* p, size_t size) { + if(size > p->allocsize) { + size_t newsize = size + (p->allocsize >> 1u); + void* data = lodepng_realloc(p->data, newsize); + if(data) { + p->allocsize = newsize; + p->data = (unsigned char*)data; + } + else return 0; /*error: not enough memory*/ + } + p->size = size; + return 1; /*success*/ +} + +static ucvector ucvector_init(unsigned char* buffer, size_t size) { + ucvector v; + v.data = buffer; + v.allocsize = v.size = size; + return v; +} + +/* ////////////////////////////////////////////////////////////////////////// */ + +#ifdef LODEPNG_COMPILE_PNG +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + +/*free string pointer and set it to NULL*/ +static void string_cleanup(char** out) { + lodepng_free(*out); + *out = NULL; +} + +/*also appends null termination character*/ +static char* alloc_string_sized(const char* in, size_t insize) { + char* out = (char*)lodepng_malloc(insize + 1); + if(out) { + lodepng_memcpy(out, in, insize); + out[insize] = 0; + } + return out; +} + +/* dynamically allocates a new string with a copy of the null terminated input text */ +static char* alloc_string(const char* in) { + return alloc_string_sized(in, lodepng_strlen(in)); +} +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ +#endif /*LODEPNG_COMPILE_PNG*/ + +/* ////////////////////////////////////////////////////////////////////////// */ + +#if defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_PNG) +static unsigned lodepng_read32bitInt(const unsigned char* buffer) { + return (((unsigned)buffer[0] << 24u) | ((unsigned)buffer[1] << 16u) | + ((unsigned)buffer[2] << 8u) | (unsigned)buffer[3]); +} +#endif /*defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_PNG)*/ + +#if defined(LODEPNG_COMPILE_PNG) || defined(LODEPNG_COMPILE_ENCODER) +/*buffer must have at least 4 allocated bytes available*/ +static void lodepng_set32bitInt(unsigned char* buffer, unsigned value) { + buffer[0] = (unsigned char)((value >> 24) & 0xff); + buffer[1] = (unsigned char)((value >> 16) & 0xff); + buffer[2] = (unsigned char)((value >> 8) & 0xff); + buffer[3] = (unsigned char)((value ) & 0xff); +} +#endif /*defined(LODEPNG_COMPILE_PNG) || defined(LODEPNG_COMPILE_ENCODER)*/ + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / File IO / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +#ifdef LODEPNG_COMPILE_DISK + +/* returns negative value on error. This should be pure C compatible, so no fstat. */ +static long lodepng_filesize(const char* filename) { + FILE* file; + long size; + file = fopen(filename, "rb"); + if(!file) return -1; + + if(fseek(file, 0, SEEK_END) != 0) { + fclose(file); + return -1; + } + + size = ftell(file); + /* It may give LONG_MAX as directory size, this is invalid for us. */ + if(size == LONG_MAX) size = -1; + + fclose(file); + return size; +} + +/* load file into buffer that already has the correct allocated size. Returns error code.*/ +static unsigned lodepng_buffer_file(unsigned char* out, size_t size, const char* filename) { + FILE* file; + size_t readsize; + file = fopen(filename, "rb"); + if(!file) return 78; + + readsize = fread(out, 1, size, file); + fclose(file); + + if(readsize != size) return 78; + return 0; +} + +unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename) { + long size = lodepng_filesize(filename); + if(size < 0) return 78; + *outsize = (size_t)size; + + *out = (unsigned char*)lodepng_malloc((size_t)size); + if(!(*out) && size > 0) return 83; /*the above malloc failed*/ + + return lodepng_buffer_file(*out, (size_t)size, filename); +} + +/*write given buffer to the file, overwriting the file, it doesn't append to it.*/ +unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename) { + FILE* file; + file = fopen(filename, "wb" ); + if(!file) return 79; + fwrite(buffer, 1, buffersize, file); + fclose(file); + return 0; +} + +#endif /*LODEPNG_COMPILE_DISK*/ + +/* ////////////////////////////////////////////////////////////////////////// */ +/* ////////////////////////////////////////////////////////////////////////// */ +/* // End of common code and tools. Begin of Zlib related code. // */ +/* ////////////////////////////////////////////////////////////////////////// */ +/* ////////////////////////////////////////////////////////////////////////// */ + +#ifdef LODEPNG_COMPILE_ZLIB +#ifdef LODEPNG_COMPILE_ENCODER + +typedef struct { + ucvector* data; + unsigned char bp; /*ok to overflow, indicates bit pos inside byte*/ +} LodePNGBitWriter; + +static void LodePNGBitWriter_init(LodePNGBitWriter* writer, ucvector* data) { + writer->data = data; + writer->bp = 0; +} + +/*TODO: this ignores potential out of memory errors*/ +#define WRITEBIT(writer, bit){\ + /* append new byte */\ + if(((writer->bp) & 7u) == 0) {\ + if(!ucvector_resize(writer->data, writer->data->size + 1)) return;\ + writer->data->data[writer->data->size - 1] = 0;\ + }\ + (writer->data->data[writer->data->size - 1]) |= (bit << ((writer->bp) & 7u));\ + ++writer->bp;\ +} + +/* LSB of value is written first, and LSB of bytes is used first */ +static void writeBits(LodePNGBitWriter* writer, unsigned value, size_t nbits) { + if(nbits == 1) { /* compiler should statically compile this case if nbits == 1 */ + WRITEBIT(writer, value); + } else { + /* TODO: increase output size only once here rather than in each WRITEBIT */ + size_t i; + for(i = 0; i != nbits; ++i) { + WRITEBIT(writer, (unsigned char)((value >> i) & 1)); + } + } +} + +/* This one is to use for adding huffman symbol, the value bits are written MSB first */ +static void writeBitsReversed(LodePNGBitWriter* writer, unsigned value, size_t nbits) { + size_t i; + for(i = 0; i != nbits; ++i) { + /* TODO: increase output size only once here rather than in each WRITEBIT */ + WRITEBIT(writer, (unsigned char)((value >> (nbits - 1u - i)) & 1u)); + } +} +#endif /*LODEPNG_COMPILE_ENCODER*/ + +#ifdef LODEPNG_COMPILE_DECODER + +typedef struct { + const unsigned char* data; + size_t size; /*size of data in bytes*/ + size_t bitsize; /*size of data in bits, end of valid bp values, should be 8*size*/ + size_t bp; + unsigned buffer; /*buffer for reading bits. NOTE: 'unsigned' must support at least 32 bits*/ +} LodePNGBitReader; + +/* data size argument is in bytes. Returns error if size too large causing overflow */ +static unsigned LodePNGBitReader_init(LodePNGBitReader* reader, const unsigned char* data, size_t size) { + size_t temp; + reader->data = data; + reader->size = size; + /* size in bits, return error if overflow (if size_t is 32 bit this supports up to 500MB) */ + if(lodepng_mulofl(size, 8u, &reader->bitsize)) return 105; + /*ensure incremented bp can be compared to bitsize without overflow even when it would be incremented 32 too much and + trying to ensure 32 more bits*/ + if(lodepng_addofl(reader->bitsize, 64u, &temp)) return 105; + reader->bp = 0; + reader->buffer = 0; + return 0; /*ok*/ +} + +/* +ensureBits functions: +Ensures the reader can at least read nbits bits in one or more readBits calls, +safely even if not enough bits are available. +Returns 1 if there are enough bits available, 0 if not. +*/ + +/*See ensureBits documentation above. This one ensures exactly 1 bit */ +/*static unsigned ensureBits1(LodePNGBitReader* reader) { + if(reader->bp >= reader->bitsize) return 0; + reader->buffer = (unsigned)reader->data[reader->bp >> 3u] >> (reader->bp & 7u); + return 1; +}*/ + +/*See ensureBits documentation above. This one ensures up to 9 bits */ +static unsigned ensureBits9(LodePNGBitReader* reader, size_t nbits) { + size_t start = reader->bp >> 3u; + size_t size = reader->size; + if(start + 1u < size) { + reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u); + reader->buffer >>= (reader->bp & 7u); + return 1; + } else { + reader->buffer = 0; + if(start + 0u < size) reader->buffer |= reader->data[start + 0]; + reader->buffer >>= (reader->bp & 7u); + return reader->bp + nbits <= reader->bitsize; + } +} + +/*See ensureBits documentation above. This one ensures up to 17 bits */ +static unsigned ensureBits17(LodePNGBitReader* reader, size_t nbits) { + size_t start = reader->bp >> 3u; + size_t size = reader->size; + if(start + 2u < size) { + reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) | + ((unsigned)reader->data[start + 2] << 16u); + reader->buffer >>= (reader->bp & 7u); + return 1; + } else { + reader->buffer = 0; + if(start + 0u < size) reader->buffer |= reader->data[start + 0]; + if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u); + reader->buffer >>= (reader->bp & 7u); + return reader->bp + nbits <= reader->bitsize; + } +} + +/*See ensureBits documentation above. This one ensures up to 25 bits */ +static LODEPNG_INLINE unsigned ensureBits25(LodePNGBitReader* reader, size_t nbits) { + size_t start = reader->bp >> 3u; + size_t size = reader->size; + if(start + 3u < size) { + reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) | + ((unsigned)reader->data[start + 2] << 16u) | ((unsigned)reader->data[start + 3] << 24u); + reader->buffer >>= (reader->bp & 7u); + return 1; + } else { + reader->buffer = 0; + if(start + 0u < size) reader->buffer |= reader->data[start + 0]; + if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u); + if(start + 2u < size) reader->buffer |= ((unsigned)reader->data[start + 2] << 16u); + reader->buffer >>= (reader->bp & 7u); + return reader->bp + nbits <= reader->bitsize; + } +} + +/*See ensureBits documentation above. This one ensures up to 32 bits */ +static LODEPNG_INLINE unsigned ensureBits32(LodePNGBitReader* reader, size_t nbits) { + size_t start = reader->bp >> 3u; + size_t size = reader->size; + if(start + 4u < size) { + reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) | + ((unsigned)reader->data[start + 2] << 16u) | ((unsigned)reader->data[start + 3] << 24u); + reader->buffer >>= (reader->bp & 7u); + reader->buffer |= (((unsigned)reader->data[start + 4] << 24u) << (8u - (reader->bp & 7u))); + return 1; + } else { + reader->buffer = 0; + if(start + 0u < size) reader->buffer |= reader->data[start + 0]; + if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u); + if(start + 2u < size) reader->buffer |= ((unsigned)reader->data[start + 2] << 16u); + if(start + 3u < size) reader->buffer |= ((unsigned)reader->data[start + 3] << 24u); + reader->buffer >>= (reader->bp & 7u); + return reader->bp + nbits <= reader->bitsize; + } +} + +/* Get bits without advancing the bit pointer. Must have enough bits available with ensureBits. Max nbits is 31. */ +static unsigned peekBits(LodePNGBitReader* reader, size_t nbits) { + /* The shift allows nbits to be only up to 31. */ + return reader->buffer & ((1u << nbits) - 1u); +} + +/* Must have enough bits available with ensureBits */ +static void advanceBits(LodePNGBitReader* reader, size_t nbits) { + reader->buffer >>= nbits; + reader->bp += nbits; +} + +/* Must have enough bits available with ensureBits */ +static unsigned readBits(LodePNGBitReader* reader, size_t nbits) { + unsigned result = peekBits(reader, nbits); + advanceBits(reader, nbits); + return result; +} + +/* Public for testing only. steps and result must have numsteps values. */ +unsigned lode_png_test_bitreader(const unsigned char* data, size_t size, + size_t numsteps, const size_t* steps, unsigned* result) { + size_t i; + LodePNGBitReader reader; + unsigned error = LodePNGBitReader_init(&reader, data, size); + if(error) return 0; + for(i = 0; i < numsteps; i++) { + size_t step = steps[i]; + unsigned ok; + if(step > 25) ok = ensureBits32(&reader, step); + else if(step > 17) ok = ensureBits25(&reader, step); + else if(step > 9) ok = ensureBits17(&reader, step); + else ok = ensureBits9(&reader, step); + if(!ok) return 0; + result[i] = readBits(&reader, step); + } + return 1; +} +#endif /*LODEPNG_COMPILE_DECODER*/ + +static unsigned reverseBits(unsigned bits, unsigned num) { + /*TODO: implement faster lookup table based version when needed*/ + unsigned i, result = 0; + for(i = 0; i < num; i++) result |= ((bits >> (num - i - 1u)) & 1u) << i; + return result; +} + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / Deflate - Huffman / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +#define FIRST_LENGTH_CODE_INDEX 257 +#define LAST_LENGTH_CODE_INDEX 285 +/*256 literals, the end code, some length codes, and 2 unused codes*/ +#define NUM_DEFLATE_CODE_SYMBOLS 288 +/*the distance codes have their own symbols, 30 used, 2 unused*/ +#define NUM_DISTANCE_SYMBOLS 32 +/*the code length codes. 0-15: code lengths, 16: copy previous 3-6 times, 17: 3-10 zeros, 18: 11-138 zeros*/ +#define NUM_CODE_LENGTH_CODES 19 + +/*the base lengths represented by codes 257-285*/ +static const unsigned LENGTHBASE[29] + = {3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, + 67, 83, 99, 115, 131, 163, 195, 227, 258}; + +/*the extra bits used by codes 257-285 (added to base length)*/ +static const unsigned LENGTHEXTRA[29] + = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, + 4, 4, 4, 4, 5, 5, 5, 5, 0}; + +/*the base backwards distances (the bits of distance codes appear after length codes and use their own huffman tree)*/ +static const unsigned DISTANCEBASE[30] + = {1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, + 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577}; + +/*the extra bits of backwards distances (added to base)*/ +static const unsigned DISTANCEEXTRA[30] + = {0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, + 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; + +/*the order in which "code length alphabet code lengths" are stored as specified by deflate, out of this the huffman +tree of the dynamic huffman tree lengths is generated*/ +static const unsigned CLCL_ORDER[NUM_CODE_LENGTH_CODES] + = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + +/* ////////////////////////////////////////////////////////////////////////// */ + +/* +Huffman tree struct, containing multiple representations of the tree +*/ +typedef struct HuffmanTree { + unsigned* codes; /*the huffman codes (bit patterns representing the symbols)*/ + unsigned* lengths; /*the lengths of the huffman codes*/ + unsigned maxbitlen; /*maximum number of bits a single code can get*/ + unsigned numcodes; /*number of symbols in the alphabet = number of codes*/ + /* for reading only */ + unsigned char* table_len; /*length of symbol from lookup table, or max length if secondary lookup needed*/ + unsigned short* table_value; /*value of symbol from lookup table, or pointer to secondary table if needed*/ +} HuffmanTree; + +static void HuffmanTree_init(HuffmanTree* tree) { + tree->codes = 0; + tree->lengths = 0; + tree->table_len = 0; + tree->table_value = 0; +} + +static void HuffmanTree_cleanup(HuffmanTree* tree) { + lodepng_free(tree->codes); + lodepng_free(tree->lengths); + lodepng_free(tree->table_len); + lodepng_free(tree->table_value); +} + +/* amount of bits for first huffman table lookup (aka root bits), see HuffmanTree_makeTable and huffmanDecodeSymbol.*/ +/* values 8u and 9u work the fastest */ +#define FIRSTBITS 9u + +/* a symbol value too big to represent any valid symbol, to indicate reading disallowed huffman bits combination, +which is possible in case of only 0 or 1 present symbols. */ +#define INVALIDSYMBOL 65535u + +/* make table for huffman decoding */ +static unsigned HuffmanTree_makeTable(HuffmanTree* tree) { + static const unsigned headsize = 1u << FIRSTBITS; /*size of the first table*/ + static const unsigned mask = (1u << FIRSTBITS) /*headsize*/ - 1u; + size_t i, numpresent, pointer, size; /*total table size*/ + unsigned* maxlens = (unsigned*)lodepng_malloc(headsize * sizeof(unsigned)); + if(!maxlens) return 83; /*alloc fail*/ + + /* compute maxlens: max total bit length of symbols sharing prefix in the first table*/ + lodepng_memset(maxlens, 0, headsize * sizeof(*maxlens)); + for(i = 0; i < tree->numcodes; i++) { + unsigned symbol = tree->codes[i]; + unsigned l = tree->lengths[i]; + unsigned index; + if(l <= FIRSTBITS) continue; /*symbols that fit in first table don't increase secondary table size*/ + /*get the FIRSTBITS MSBs, the MSBs of the symbol are encoded first. See later comment about the reversing*/ + index = reverseBits(symbol >> (l - FIRSTBITS), FIRSTBITS); + maxlens[index] = LODEPNG_MAX(maxlens[index], l); + } + /* compute total table size: size of first table plus all secondary tables for symbols longer than FIRSTBITS */ + size = headsize; + for(i = 0; i < headsize; ++i) { + unsigned l = maxlens[i]; + if(l > FIRSTBITS) size += (1u << (l - FIRSTBITS)); + } + tree->table_len = (unsigned char*)lodepng_malloc(size * sizeof(*tree->table_len)); + tree->table_value = (unsigned short*)lodepng_malloc(size * sizeof(*tree->table_value)); + if(!tree->table_len || !tree->table_value) { + lodepng_free(maxlens); + /* freeing tree->table values is done at a higher scope */ + return 83; /*alloc fail*/ + } + /*initialize with an invalid length to indicate unused entries*/ + for(i = 0; i < size; ++i) tree->table_len[i] = 16; + + /*fill in the first table for long symbols: max prefix size and pointer to secondary tables*/ + pointer = headsize; + for(i = 0; i < headsize; ++i) { + unsigned l = maxlens[i]; + if(l <= FIRSTBITS) continue; + tree->table_len[i] = l; + tree->table_value[i] = pointer; + pointer += (1u << (l - FIRSTBITS)); + } + lodepng_free(maxlens); + + /*fill in the first table for short symbols, or secondary table for long symbols*/ + numpresent = 0; + for(i = 0; i < tree->numcodes; ++i) { + unsigned l = tree->lengths[i]; + unsigned symbol = tree->codes[i]; /*the huffman bit pattern. i itself is the value.*/ + /*reverse bits, because the huffman bits are given in MSB first order but the bit reader reads LSB first*/ + unsigned reverse = reverseBits(symbol, l); + if(l == 0) continue; + numpresent++; + + if(l <= FIRSTBITS) { + /*short symbol, fully in first table, replicated num times if l < FIRSTBITS*/ + unsigned num = 1u << (FIRSTBITS - l); + unsigned j; + for(j = 0; j < num; ++j) { + /*bit reader will read the l bits of symbol first, the remaining FIRSTBITS - l bits go to the MSB's*/ + unsigned index = reverse | (j << l); + if(tree->table_len[index] != 16) return 55; /*invalid tree: long symbol shares prefix with short symbol*/ + tree->table_len[index] = l; + tree->table_value[index] = i; + } + } else { + /*long symbol, shares prefix with other long symbols in first lookup table, needs second lookup*/ + /*the FIRSTBITS MSBs of the symbol are the first table index*/ + unsigned index = reverse & mask; + unsigned maxlen = tree->table_len[index]; + /*log2 of secondary table length, should be >= l - FIRSTBITS*/ + unsigned tablelen = maxlen - FIRSTBITS; + unsigned start = tree->table_value[index]; /*starting index in secondary table*/ + unsigned num = 1u << (tablelen - (l - FIRSTBITS)); /*amount of entries of this symbol in secondary table*/ + unsigned j; + if(maxlen < l) return 55; /*invalid tree: long symbol shares prefix with short symbol*/ + for(j = 0; j < num; ++j) { + unsigned reverse2 = reverse >> FIRSTBITS; /* l - FIRSTBITS bits */ + unsigned index2 = start + (reverse2 | (j << (l - FIRSTBITS))); + tree->table_len[index2] = l; + tree->table_value[index2] = i; + } + } + } + + if(numpresent < 2) { + /* In case of exactly 1 symbol, in theory the huffman symbol needs 0 bits, + but deflate uses 1 bit instead. In case of 0 symbols, no symbols can + appear at all, but such huffman tree could still exist (e.g. if distance + codes are never used). In both cases, not all symbols of the table will be + filled in. Fill them in with an invalid symbol value so returning them from + huffmanDecodeSymbol will cause error. */ + for(i = 0; i < size; ++i) { + if(tree->table_len[i] == 16) { + /* As length, use a value smaller than FIRSTBITS for the head table, + and a value larger than FIRSTBITS for the secondary table, to ensure + valid behavior for advanceBits when reading this symbol. */ + tree->table_len[i] = (i < headsize) ? 1 : (FIRSTBITS + 1); + tree->table_value[i] = INVALIDSYMBOL; + } + } + } else { + /* A good huffman tree has N * 2 - 1 nodes, of which N - 1 are internal nodes. + If that is not the case (due to too long length codes), the table will not + have been fully used, and this is an error (not all bit combinations can be + decoded): an oversubscribed huffman tree, indicated by error 55. */ + for(i = 0; i < size; ++i) { + if(tree->table_len[i] == 16) return 55; + } + } + + return 0; +} + +/* +Second step for the ...makeFromLengths and ...makeFromFrequencies functions. +numcodes, lengths and maxbitlen must already be filled in correctly. return +value is error. +*/ +static unsigned HuffmanTree_makeFromLengths2(HuffmanTree* tree) { + unsigned* blcount; + unsigned* nextcode; + unsigned error = 0; + unsigned bits, n; + + tree->codes = (unsigned*)lodepng_malloc(tree->numcodes * sizeof(unsigned)); + blcount = (unsigned*)lodepng_malloc((tree->maxbitlen + 1) * sizeof(unsigned)); + nextcode = (unsigned*)lodepng_malloc((tree->maxbitlen + 1) * sizeof(unsigned)); + if(!tree->codes || !blcount || !nextcode) error = 83; /*alloc fail*/ + + if(!error) { + for(n = 0; n != tree->maxbitlen + 1; n++) blcount[n] = nextcode[n] = 0; + /*step 1: count number of instances of each code length*/ + for(bits = 0; bits != tree->numcodes; ++bits) ++blcount[tree->lengths[bits]]; + /*step 2: generate the nextcode values*/ + for(bits = 1; bits <= tree->maxbitlen; ++bits) { + nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1]) << 1u; + } + /*step 3: generate all the codes*/ + for(n = 0; n != tree->numcodes; ++n) { + if(tree->lengths[n] != 0) { + tree->codes[n] = nextcode[tree->lengths[n]]++; + /*remove superfluous bits from the code*/ + tree->codes[n] &= ((1u << tree->lengths[n]) - 1u); + } + } + } + + lodepng_free(blcount); + lodepng_free(nextcode); + + if(!error) error = HuffmanTree_makeTable(tree); + return error; +} + +/* +given the code lengths (as stored in the PNG file), generate the tree as defined +by Deflate. maxbitlen is the maximum bits that a code in the tree can have. +return value is error. +*/ +static unsigned HuffmanTree_makeFromLengths(HuffmanTree* tree, const unsigned* bitlen, + size_t numcodes, unsigned maxbitlen) { + unsigned i; + tree->lengths = (unsigned*)lodepng_malloc(numcodes * sizeof(unsigned)); + if(!tree->lengths) return 83; /*alloc fail*/ + for(i = 0; i != numcodes; ++i) tree->lengths[i] = bitlen[i]; + tree->numcodes = (unsigned)numcodes; /*number of symbols*/ + tree->maxbitlen = maxbitlen; + return HuffmanTree_makeFromLengths2(tree); +} + +#ifdef LODEPNG_COMPILE_ENCODER + +/*BPM: Boundary Package Merge, see "A Fast and Space-Economical Algorithm for Length-Limited Coding", +Jyrki Katajainen, Alistair Moffat, Andrew Turpin, 1995.*/ + +/*chain node for boundary package merge*/ +typedef struct BPMNode { + int weight; /*the sum of all weights in this chain*/ + unsigned index; /*index of this leaf node (called "count" in the paper)*/ + struct BPMNode* tail; /*the next nodes in this chain (null if last)*/ + int in_use; +} BPMNode; + +/*lists of chains*/ +typedef struct BPMLists { + /*memory pool*/ + unsigned memsize; + BPMNode* memory; + unsigned numfree; + unsigned nextfree; + BPMNode** freelist; + /*two heads of lookahead chains per list*/ + unsigned listsize; + BPMNode** chains0; + BPMNode** chains1; +} BPMLists; + +/*creates a new chain node with the given parameters, from the memory in the lists */ +static BPMNode* bpmnode_create(BPMLists* lists, int weight, unsigned index, BPMNode* tail) { + unsigned i; + BPMNode* result; + + /*memory full, so garbage collect*/ + if(lists->nextfree >= lists->numfree) { + /*mark only those that are in use*/ + for(i = 0; i != lists->memsize; ++i) lists->memory[i].in_use = 0; + for(i = 0; i != lists->listsize; ++i) { + BPMNode* node; + for(node = lists->chains0[i]; node != 0; node = node->tail) node->in_use = 1; + for(node = lists->chains1[i]; node != 0; node = node->tail) node->in_use = 1; + } + /*collect those that are free*/ + lists->numfree = 0; + for(i = 0; i != lists->memsize; ++i) { + if(!lists->memory[i].in_use) lists->freelist[lists->numfree++] = &lists->memory[i]; + } + lists->nextfree = 0; + } + + result = lists->freelist[lists->nextfree++]; + result->weight = weight; + result->index = index; + result->tail = tail; + return result; +} + +/*sort the leaves with stable mergesort*/ +static void bpmnode_sort(BPMNode* leaves, size_t num) { + BPMNode* mem = (BPMNode*)lodepng_malloc(sizeof(*leaves) * num); + size_t width, counter = 0; + for(width = 1; width < num; width *= 2) { + BPMNode* a = (counter & 1) ? mem : leaves; + BPMNode* b = (counter & 1) ? leaves : mem; + size_t p; + for(p = 0; p < num; p += 2 * width) { + size_t q = (p + width > num) ? num : (p + width); + size_t r = (p + 2 * width > num) ? num : (p + 2 * width); + size_t i = p, j = q, k; + for(k = p; k < r; k++) { + if(i < q && (j >= r || a[i].weight <= a[j].weight)) b[k] = a[i++]; + else b[k] = a[j++]; + } + } + counter++; + } + if(counter & 1) lodepng_memcpy(leaves, mem, sizeof(*leaves) * num); + lodepng_free(mem); +} + +/*Boundary Package Merge step, numpresent is the amount of leaves, and c is the current chain.*/ +static void boundaryPM(BPMLists* lists, BPMNode* leaves, size_t numpresent, int c, int num) { + unsigned lastindex = lists->chains1[c]->index; + + if(c == 0) { + if(lastindex >= numpresent) return; + lists->chains0[c] = lists->chains1[c]; + lists->chains1[c] = bpmnode_create(lists, leaves[lastindex].weight, lastindex + 1, 0); + } else { + /*sum of the weights of the head nodes of the previous lookahead chains.*/ + int sum = lists->chains0[c - 1]->weight + lists->chains1[c - 1]->weight; + lists->chains0[c] = lists->chains1[c]; + if(lastindex < numpresent && sum > leaves[lastindex].weight) { + lists->chains1[c] = bpmnode_create(lists, leaves[lastindex].weight, lastindex + 1, lists->chains1[c]->tail); + return; + } + lists->chains1[c] = bpmnode_create(lists, sum, lastindex, lists->chains1[c - 1]); + /*in the end we are only interested in the chain of the last list, so no + need to recurse if we're at the last one (this gives measurable speedup)*/ + if(num + 1 < (int)(2 * numpresent - 2)) { + boundaryPM(lists, leaves, numpresent, c - 1, num); + boundaryPM(lists, leaves, numpresent, c - 1, num); + } + } +} + +unsigned lodepng_huffman_code_lengths(unsigned* lengths, const unsigned* frequencies, + size_t numcodes, unsigned maxbitlen) { + unsigned error = 0; + unsigned i; + size_t numpresent = 0; /*number of symbols with non-zero frequency*/ + BPMNode* leaves; /*the symbols, only those with > 0 frequency*/ + + if(numcodes == 0) return 80; /*error: a tree of 0 symbols is not supposed to be made*/ + if((1u << maxbitlen) < (unsigned)numcodes) return 80; /*error: represent all symbols*/ + + leaves = (BPMNode*)lodepng_malloc(numcodes * sizeof(*leaves)); + if(!leaves) return 83; /*alloc fail*/ + + for(i = 0; i != numcodes; ++i) { + if(frequencies[i] > 0) { + leaves[numpresent].weight = (int)frequencies[i]; + leaves[numpresent].index = i; + ++numpresent; + } + } + + lodepng_memset(lengths, 0, numcodes * sizeof(*lengths)); + + /*ensure at least two present symbols. There should be at least one symbol + according to RFC 1951 section 3.2.7. Some decoders incorrectly require two. To + make these work as well ensure there are at least two symbols. The + Package-Merge code below also doesn't work correctly if there's only one + symbol, it'd give it the theoretical 0 bits but in practice zlib wants 1 bit*/ + if(numpresent == 0) { + lengths[0] = lengths[1] = 1; /*note that for RFC 1951 section 3.2.7, only lengths[0] = 1 is needed*/ + } else if(numpresent == 1) { + lengths[leaves[0].index] = 1; + lengths[leaves[0].index == 0 ? 1 : 0] = 1; + } else { + BPMLists lists; + BPMNode* node; + + bpmnode_sort(leaves, numpresent); + + lists.listsize = maxbitlen; + lists.memsize = 2 * maxbitlen * (maxbitlen + 1); + lists.nextfree = 0; + lists.numfree = lists.memsize; + lists.memory = (BPMNode*)lodepng_malloc(lists.memsize * sizeof(*lists.memory)); + lists.freelist = (BPMNode**)lodepng_malloc(lists.memsize * sizeof(BPMNode*)); + lists.chains0 = (BPMNode**)lodepng_malloc(lists.listsize * sizeof(BPMNode*)); + lists.chains1 = (BPMNode**)lodepng_malloc(lists.listsize * sizeof(BPMNode*)); + if(!lists.memory || !lists.freelist || !lists.chains0 || !lists.chains1) error = 83; /*alloc fail*/ + + if(!error) { + for(i = 0; i != lists.memsize; ++i) lists.freelist[i] = &lists.memory[i]; + + bpmnode_create(&lists, leaves[0].weight, 1, 0); + bpmnode_create(&lists, leaves[1].weight, 2, 0); + + for(i = 0; i != lists.listsize; ++i) { + lists.chains0[i] = &lists.memory[0]; + lists.chains1[i] = &lists.memory[1]; + } + + /*each boundaryPM call adds one chain to the last list, and we need 2 * numpresent - 2 chains.*/ + for(i = 2; i != 2 * numpresent - 2; ++i) boundaryPM(&lists, leaves, numpresent, (int)maxbitlen - 1, (int)i); + + for(node = lists.chains1[maxbitlen - 1]; node; node = node->tail) { + for(i = 0; i != node->index; ++i) ++lengths[leaves[i].index]; + } + } + + lodepng_free(lists.memory); + lodepng_free(lists.freelist); + lodepng_free(lists.chains0); + lodepng_free(lists.chains1); + } + + lodepng_free(leaves); + return error; +} + +/*Create the Huffman tree given the symbol frequencies*/ +static unsigned HuffmanTree_makeFromFrequencies(HuffmanTree* tree, const unsigned* frequencies, + size_t mincodes, size_t numcodes, unsigned maxbitlen) { + unsigned error = 0; + while(!frequencies[numcodes - 1] && numcodes > mincodes) --numcodes; /*trim zeroes*/ + tree->lengths = (unsigned*)lodepng_malloc(numcodes * sizeof(unsigned)); + if(!tree->lengths) return 83; /*alloc fail*/ + tree->maxbitlen = maxbitlen; + tree->numcodes = (unsigned)numcodes; /*number of symbols*/ + + error = lodepng_huffman_code_lengths(tree->lengths, frequencies, numcodes, maxbitlen); + if(!error) error = HuffmanTree_makeFromLengths2(tree); + return error; +} +#endif /*LODEPNG_COMPILE_ENCODER*/ + +/*get the literal and length code tree of a deflated block with fixed tree, as per the deflate specification*/ +static unsigned generateFixedLitLenTree(HuffmanTree* tree) { + unsigned i, error = 0; + unsigned* bitlen = (unsigned*)lodepng_malloc(NUM_DEFLATE_CODE_SYMBOLS * sizeof(unsigned)); + if(!bitlen) return 83; /*alloc fail*/ + + /*288 possible codes: 0-255=literals, 256=endcode, 257-285=lengthcodes, 286-287=unused*/ + for(i = 0; i <= 143; ++i) bitlen[i] = 8; + for(i = 144; i <= 255; ++i) bitlen[i] = 9; + for(i = 256; i <= 279; ++i) bitlen[i] = 7; + for(i = 280; i <= 287; ++i) bitlen[i] = 8; + + error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DEFLATE_CODE_SYMBOLS, 15); + + lodepng_free(bitlen); + return error; +} + +/*get the distance code tree of a deflated block with fixed tree, as specified in the deflate specification*/ +static unsigned generateFixedDistanceTree(HuffmanTree* tree) { + unsigned i, error = 0; + unsigned* bitlen = (unsigned*)lodepng_malloc(NUM_DISTANCE_SYMBOLS * sizeof(unsigned)); + if(!bitlen) return 83; /*alloc fail*/ + + /*there are 32 distance codes, but 30-31 are unused*/ + for(i = 0; i != NUM_DISTANCE_SYMBOLS; ++i) bitlen[i] = 5; + error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DISTANCE_SYMBOLS, 15); + + lodepng_free(bitlen); + return error; +} + +#ifdef LODEPNG_COMPILE_DECODER + +/* +returns the code. The bit reader must already have been ensured at least 15 bits +*/ +static unsigned huffmanDecodeSymbol(LodePNGBitReader* reader, const HuffmanTree* codetree) { + unsigned short code = peekBits(reader, FIRSTBITS); + unsigned short l = codetree->table_len[code]; + unsigned short value = codetree->table_value[code]; + if(l <= FIRSTBITS) { + advanceBits(reader, l); + return value; + } else { + unsigned index2; + advanceBits(reader, FIRSTBITS); + index2 = value + peekBits(reader, l - FIRSTBITS); + advanceBits(reader, codetree->table_len[index2] - FIRSTBITS); + return codetree->table_value[index2]; + } +} +#endif /*LODEPNG_COMPILE_DECODER*/ + +#ifdef LODEPNG_COMPILE_DECODER + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / Inflator (Decompressor) / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +/*get the tree of a deflated block with fixed tree, as specified in the deflate specification +Returns error code.*/ +static unsigned getTreeInflateFixed(HuffmanTree* tree_ll, HuffmanTree* tree_d) { + unsigned error = generateFixedLitLenTree(tree_ll); + if(error) return error; + return generateFixedDistanceTree(tree_d); +} + +/*get the tree of a deflated block with dynamic tree, the tree itself is also Huffman compressed with a known tree*/ +static unsigned getTreeInflateDynamic(HuffmanTree* tree_ll, HuffmanTree* tree_d, + LodePNGBitReader* reader) { + /*make sure that length values that aren't filled in will be 0, or a wrong tree will be generated*/ + unsigned error = 0; + unsigned n, HLIT, HDIST, HCLEN, i; + + /*see comments in deflateDynamic for explanation of the context and these variables, it is analogous*/ + unsigned* bitlen_ll = 0; /*lit,len code lengths*/ + unsigned* bitlen_d = 0; /*dist code lengths*/ + /*code length code lengths ("clcl"), the bit lengths of the huffman tree used to compress bitlen_ll and bitlen_d*/ + unsigned* bitlen_cl = 0; + HuffmanTree tree_cl; /*the code tree for code length codes (the huffman tree for compressed huffman trees)*/ + + if(!ensureBits17(reader, 14)) return 49; /*error: the bit pointer is or will go past the memory*/ + + /*number of literal/length codes + 257. Unlike the spec, the value 257 is added to it here already*/ + HLIT = readBits(reader, 5) + 257; + /*number of distance codes. Unlike the spec, the value 1 is added to it here already*/ + HDIST = readBits(reader, 5) + 1; + /*number of code length codes. Unlike the spec, the value 4 is added to it here already*/ + HCLEN = readBits(reader, 4) + 4; + + bitlen_cl = (unsigned*)lodepng_malloc(NUM_CODE_LENGTH_CODES * sizeof(unsigned)); + if(!bitlen_cl) return 83 /*alloc fail*/; + + HuffmanTree_init(&tree_cl); + + while(!error) { + /*read the code length codes out of 3 * (amount of code length codes) bits*/ + if(lodepng_gtofl(reader->bp, HCLEN * 3, reader->bitsize)) { + ERROR_BREAK(50); /*error: the bit pointer is or will go past the memory*/ + } + for(i = 0; i != HCLEN; ++i) { + ensureBits9(reader, 3); /*out of bounds already checked above */ + bitlen_cl[CLCL_ORDER[i]] = readBits(reader, 3); + } + for(i = HCLEN; i != NUM_CODE_LENGTH_CODES; ++i) { + bitlen_cl[CLCL_ORDER[i]] = 0; + } + + error = HuffmanTree_makeFromLengths(&tree_cl, bitlen_cl, NUM_CODE_LENGTH_CODES, 7); + if(error) break; + + /*now we can use this tree to read the lengths for the tree that this function will return*/ + bitlen_ll = (unsigned*)lodepng_malloc(NUM_DEFLATE_CODE_SYMBOLS * sizeof(unsigned)); + bitlen_d = (unsigned*)lodepng_malloc(NUM_DISTANCE_SYMBOLS * sizeof(unsigned)); + if(!bitlen_ll || !bitlen_d) ERROR_BREAK(83 /*alloc fail*/); + lodepng_memset(bitlen_ll, 0, NUM_DEFLATE_CODE_SYMBOLS * sizeof(*bitlen_ll)); + lodepng_memset(bitlen_d, 0, NUM_DISTANCE_SYMBOLS * sizeof(*bitlen_d)); + + /*i is the current symbol we're reading in the part that contains the code lengths of lit/len and dist codes*/ + i = 0; + while(i < HLIT + HDIST) { + unsigned code; + ensureBits25(reader, 22); /* up to 15 bits for huffman code, up to 7 extra bits below*/ + code = huffmanDecodeSymbol(reader, &tree_cl); + if(code <= 15) /*a length code*/ { + if(i < HLIT) bitlen_ll[i] = code; + else bitlen_d[i - HLIT] = code; + ++i; + } else if(code == 16) /*repeat previous*/ { + unsigned replength = 3; /*read in the 2 bits that indicate repeat length (3-6)*/ + unsigned value; /*set value to the previous code*/ + + if(i == 0) ERROR_BREAK(54); /*can't repeat previous if i is 0*/ + + replength += readBits(reader, 2); + + if(i < HLIT + 1) value = bitlen_ll[i - 1]; + else value = bitlen_d[i - HLIT - 1]; + /*repeat this value in the next lengths*/ + for(n = 0; n < replength; ++n) { + if(i >= HLIT + HDIST) ERROR_BREAK(13); /*error: i is larger than the amount of codes*/ + if(i < HLIT) bitlen_ll[i] = value; + else bitlen_d[i - HLIT] = value; + ++i; + } + } else if(code == 17) /*repeat "0" 3-10 times*/ { + unsigned replength = 3; /*read in the bits that indicate repeat length*/ + replength += readBits(reader, 3); + + /*repeat this value in the next lengths*/ + for(n = 0; n < replength; ++n) { + if(i >= HLIT + HDIST) ERROR_BREAK(14); /*error: i is larger than the amount of codes*/ + + if(i < HLIT) bitlen_ll[i] = 0; + else bitlen_d[i - HLIT] = 0; + ++i; + } + } else if(code == 18) /*repeat "0" 11-138 times*/ { + unsigned replength = 11; /*read in the bits that indicate repeat length*/ + replength += readBits(reader, 7); + + /*repeat this value in the next lengths*/ + for(n = 0; n < replength; ++n) { + if(i >= HLIT + HDIST) ERROR_BREAK(15); /*error: i is larger than the amount of codes*/ + + if(i < HLIT) bitlen_ll[i] = 0; + else bitlen_d[i - HLIT] = 0; + ++i; + } + } else /*if(code == INVALIDSYMBOL)*/ { + ERROR_BREAK(16); /*error: tried to read disallowed huffman symbol*/ + } + /*check if any of the ensureBits above went out of bounds*/ + if(reader->bp > reader->bitsize) { + /*return error code 10 or 11 depending on the situation that happened in huffmanDecodeSymbol + (10=no endcode, 11=wrong jump outside of tree)*/ + /* TODO: revise error codes 10,11,50: the above comment is no longer valid */ + ERROR_BREAK(50); /*error, bit pointer jumps past memory*/ + } + } + if(error) break; + + if(bitlen_ll[256] == 0) ERROR_BREAK(64); /*the length of the end code 256 must be larger than 0*/ + + /*now we've finally got HLIT and HDIST, so generate the code trees, and the function is done*/ + error = HuffmanTree_makeFromLengths(tree_ll, bitlen_ll, NUM_DEFLATE_CODE_SYMBOLS, 15); + if(error) break; + error = HuffmanTree_makeFromLengths(tree_d, bitlen_d, NUM_DISTANCE_SYMBOLS, 15); + + break; /*end of error-while*/ + } + + lodepng_free(bitlen_cl); + lodepng_free(bitlen_ll); + lodepng_free(bitlen_d); + HuffmanTree_cleanup(&tree_cl); + + return error; +} + +/*inflate a block with dynamic of fixed Huffman tree. btype must be 1 or 2.*/ +static unsigned inflateHuffmanBlock(ucvector* out, LodePNGBitReader* reader, + unsigned btype, size_t max_output_size) { + unsigned error = 0; + HuffmanTree tree_ll; /*the huffman tree for literal and length codes*/ + HuffmanTree tree_d; /*the huffman tree for distance codes*/ + + HuffmanTree_init(&tree_ll); + HuffmanTree_init(&tree_d); + + if(btype == 1) error = getTreeInflateFixed(&tree_ll, &tree_d); + else /*if(btype == 2)*/ error = getTreeInflateDynamic(&tree_ll, &tree_d, reader); + + while(!error) /*decode all symbols until end reached, breaks at end code*/ { + /*code_ll is literal, length or end code*/ + unsigned code_ll; + ensureBits25(reader, 20); /* up to 15 for the huffman symbol, up to 5 for the length extra bits */ + code_ll = huffmanDecodeSymbol(reader, &tree_ll); + if(code_ll <= 255) /*literal symbol*/ { + if(!ucvector_resize(out, out->size + 1)) ERROR_BREAK(83 /*alloc fail*/); + out->data[out->size - 1] = (unsigned char)code_ll; + } else if(code_ll >= FIRST_LENGTH_CODE_INDEX && code_ll <= LAST_LENGTH_CODE_INDEX) /*length code*/ { + unsigned code_d, distance; + unsigned numextrabits_l, numextrabits_d; /*extra bits for length and distance*/ + size_t start, backward, length; + + /*part 1: get length base*/ + length = LENGTHBASE[code_ll - FIRST_LENGTH_CODE_INDEX]; + + /*part 2: get extra bits and add the value of that to length*/ + numextrabits_l = LENGTHEXTRA[code_ll - FIRST_LENGTH_CODE_INDEX]; + if(numextrabits_l != 0) { + /* bits already ensured above */ + length += readBits(reader, numextrabits_l); + } + + /*part 3: get distance code*/ + ensureBits32(reader, 28); /* up to 15 for the huffman symbol, up to 13 for the extra bits */ + code_d = huffmanDecodeSymbol(reader, &tree_d); + if(code_d > 29) { + if(code_d <= 31) { + ERROR_BREAK(18); /*error: invalid distance code (30-31 are never used)*/ + } else /* if(code_d == INVALIDSYMBOL) */{ + ERROR_BREAK(16); /*error: tried to read disallowed huffman symbol*/ + } + } + distance = DISTANCEBASE[code_d]; + + /*part 4: get extra bits from distance*/ + numextrabits_d = DISTANCEEXTRA[code_d]; + if(numextrabits_d != 0) { + /* bits already ensured above */ + distance += readBits(reader, numextrabits_d); + } + + /*part 5: fill in all the out[n] values based on the length and dist*/ + start = out->size; + if(distance > start) ERROR_BREAK(52); /*too long backward distance*/ + backward = start - distance; + + if(!ucvector_resize(out, out->size + length)) ERROR_BREAK(83 /*alloc fail*/); + if(distance < length) { + size_t forward; + lodepng_memcpy(out->data + start, out->data + backward, distance); + start += distance; + for(forward = distance; forward < length; ++forward) { + out->data[start++] = out->data[backward++]; + } + } else { + lodepng_memcpy(out->data + start, out->data + backward, length); + } + } else if(code_ll == 256) { + break; /*end code, break the loop*/ + } else /*if(code_ll == INVALIDSYMBOL)*/ { + ERROR_BREAK(16); /*error: tried to read disallowed huffman symbol*/ + } + /*check if any of the ensureBits above went out of bounds*/ + if(reader->bp > reader->bitsize) { + /*return error code 10 or 11 depending on the situation that happened in huffmanDecodeSymbol + (10=no endcode, 11=wrong jump outside of tree)*/ + /* TODO: revise error codes 10,11,50: the above comment is no longer valid */ + ERROR_BREAK(51); /*error, bit pointer jumps past memory*/ + } + if(max_output_size && out->size > max_output_size) { + ERROR_BREAK(109); /*error, larger than max size*/ + } + } + + HuffmanTree_cleanup(&tree_ll); + HuffmanTree_cleanup(&tree_d); + + return error; +} + +static unsigned inflateNoCompression(ucvector* out, LodePNGBitReader* reader, + const LodePNGDecompressSettings* settings) { + size_t bytepos; + size_t size = reader->size; + unsigned LEN, NLEN, error = 0; + + /*go to first boundary of byte*/ + bytepos = (reader->bp + 7u) >> 3u; + + /*read LEN (2 bytes) and NLEN (2 bytes)*/ + if(bytepos + 4 >= size) return 52; /*error, bit pointer will jump past memory*/ + LEN = (unsigned)reader->data[bytepos] + ((unsigned)reader->data[bytepos + 1] << 8u); bytepos += 2; + NLEN = (unsigned)reader->data[bytepos] + ((unsigned)reader->data[bytepos + 1] << 8u); bytepos += 2; + + /*check if 16-bit NLEN is really the one's complement of LEN*/ + if(!settings->ignore_nlen && LEN + NLEN != 65535) { + return 21; /*error: NLEN is not one's complement of LEN*/ + } + + if(!ucvector_resize(out, out->size + LEN)) return 83; /*alloc fail*/ + + /*read the literal data: LEN bytes are now stored in the out buffer*/ + if(bytepos + LEN > size) return 23; /*error: reading outside of in buffer*/ + + lodepng_memcpy(out->data + out->size - LEN, reader->data + bytepos, LEN); + bytepos += LEN; + + reader->bp = bytepos << 3u; + + return error; +} + +static unsigned lodepng_inflatev(ucvector* out, + const unsigned char* in, size_t insize, + const LodePNGDecompressSettings* settings) { + unsigned BFINAL = 0; + LodePNGBitReader reader; + unsigned error = LodePNGBitReader_init(&reader, in, insize); + + if(error) return error; + + while(!BFINAL) { + unsigned BTYPE; + if(!ensureBits9(&reader, 3)) return 52; /*error, bit pointer will jump past memory*/ + BFINAL = readBits(&reader, 1); + BTYPE = readBits(&reader, 2); + + if(BTYPE == 3) return 20; /*error: invalid BTYPE*/ + else if(BTYPE == 0) error = inflateNoCompression(out, &reader, settings); /*no compression*/ + else error = inflateHuffmanBlock(out, &reader, BTYPE, settings->max_output_size); /*compression, BTYPE 01 or 10*/ + if(!error && settings->max_output_size && out->size > settings->max_output_size) error = 109; + if(error) break; + } + + return error; +} + +unsigned lodepng_inflate(unsigned char** out, size_t* outsize, + const unsigned char* in, size_t insize, + const LodePNGDecompressSettings* settings) { + ucvector v = ucvector_init(*out, *outsize); + unsigned error = lodepng_inflatev(&v, in, insize, settings); + *out = v.data; + *outsize = v.size; + return error; +} + +static unsigned inflatev(ucvector* out, const unsigned char* in, size_t insize, + const LodePNGDecompressSettings* settings) { + if(settings->custom_inflate) { + unsigned error = settings->custom_inflate(&out->data, &out->size, in, insize, settings); + out->allocsize = out->size; + if(error) { + /*the custom inflate is allowed to have its own error codes, however, we translate it to code 110*/ + error = 110; + /*if there's a max output size, and the custom zlib returned error, then indicate that error instead*/ + if(settings->max_output_size && out->size > settings->max_output_size) error = 109; + } + return error; + } else { + return lodepng_inflatev(out, in, insize, settings); + } +} + +#endif /*LODEPNG_COMPILE_DECODER*/ + +#ifdef LODEPNG_COMPILE_ENCODER + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / Deflator (Compressor) / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +static const size_t MAX_SUPPORTED_DEFLATE_LENGTH = 258; + +/*search the index in the array, that has the largest value smaller than or equal to the given value, +given array must be sorted (if no value is smaller, it returns the size of the given array)*/ +static size_t searchCodeIndex(const unsigned* array, size_t array_size, size_t value) { + /*binary search (only small gain over linear). TODO: use CPU log2 instruction for getting symbols instead*/ + size_t left = 1; + size_t right = array_size - 1; + + while(left <= right) { + size_t mid = (left + right) >> 1; + if(array[mid] >= value) right = mid - 1; + else left = mid + 1; + } + if(left >= array_size || array[left] > value) left--; + return left; +} + +static void addLengthDistance(uivector* values, size_t length, size_t distance) { + /*values in encoded vector are those used by deflate: + 0-255: literal bytes + 256: end + 257-285: length/distance pair (length code, followed by extra length bits, distance code, extra distance bits) + 286-287: invalid*/ + + unsigned length_code = (unsigned)searchCodeIndex(LENGTHBASE, 29, length); + unsigned extra_length = (unsigned)(length - LENGTHBASE[length_code]); + unsigned dist_code = (unsigned)searchCodeIndex(DISTANCEBASE, 30, distance); + unsigned extra_distance = (unsigned)(distance - DISTANCEBASE[dist_code]); + + size_t pos = values->size; + /*TODO: return error when this fails (out of memory)*/ + unsigned ok = uivector_resize(values, values->size + 4); + if(ok) { + values->data[pos + 0] = length_code + FIRST_LENGTH_CODE_INDEX; + values->data[pos + 1] = extra_length; + values->data[pos + 2] = dist_code; + values->data[pos + 3] = extra_distance; + } +} + +/*3 bytes of data get encoded into two bytes. The hash cannot use more than 3 +bytes as input because 3 is the minimum match length for deflate*/ +static const unsigned HASH_NUM_VALUES = 65536; +static const unsigned HASH_BIT_MASK = 65535; /*HASH_NUM_VALUES - 1, but C90 does not like that as initializer*/ + +typedef struct Hash { + int* head; /*hash value to head circular pos - can be outdated if went around window*/ + /*circular pos to prev circular pos*/ + unsigned short* chain; + int* val; /*circular pos to hash value*/ + + /*TODO: do this not only for zeros but for any repeated byte. However for PNG + it's always going to be the zeros that dominate, so not important for PNG*/ + int* headz; /*similar to head, but for chainz*/ + unsigned short* chainz; /*those with same amount of zeros*/ + unsigned short* zeros; /*length of zeros streak, used as a second hash chain*/ +} Hash; + +static unsigned hash_init(Hash* hash, unsigned windowsize) { + unsigned i; + hash->head = (int*)lodepng_malloc(sizeof(int) * HASH_NUM_VALUES); + hash->val = (int*)lodepng_malloc(sizeof(int) * windowsize); + hash->chain = (unsigned short*)lodepng_malloc(sizeof(unsigned short) * windowsize); + + hash->zeros = (unsigned short*)lodepng_malloc(sizeof(unsigned short) * windowsize); + hash->headz = (int*)lodepng_malloc(sizeof(int) * (MAX_SUPPORTED_DEFLATE_LENGTH + 1)); + hash->chainz = (unsigned short*)lodepng_malloc(sizeof(unsigned short) * windowsize); + + if(!hash->head || !hash->chain || !hash->val || !hash->headz|| !hash->chainz || !hash->zeros) { + return 83; /*alloc fail*/ + } + + /*initialize hash table*/ + for(i = 0; i != HASH_NUM_VALUES; ++i) hash->head[i] = -1; + for(i = 0; i != windowsize; ++i) hash->val[i] = -1; + for(i = 0; i != windowsize; ++i) hash->chain[i] = i; /*same value as index indicates uninitialized*/ + + for(i = 0; i <= MAX_SUPPORTED_DEFLATE_LENGTH; ++i) hash->headz[i] = -1; + for(i = 0; i != windowsize; ++i) hash->chainz[i] = i; /*same value as index indicates uninitialized*/ + + return 0; +} + +static void hash_cleanup(Hash* hash) { + lodepng_free(hash->head); + lodepng_free(hash->val); + lodepng_free(hash->chain); + + lodepng_free(hash->zeros); + lodepng_free(hash->headz); + lodepng_free(hash->chainz); +} + + + +static unsigned getHash(const unsigned char* data, size_t size, size_t pos) { + unsigned result = 0; + if(pos + 2 < size) { + /*A simple shift and xor hash is used. Since the data of PNGs is dominated + by zeroes due to the filters, a better hash does not have a significant + effect on speed in traversing the chain, and causes more time spend on + calculating the hash.*/ + result ^= ((unsigned)data[pos + 0] << 0u); + result ^= ((unsigned)data[pos + 1] << 4u); + result ^= ((unsigned)data[pos + 2] << 8u); + } else { + size_t amount, i; + if(pos >= size) return 0; + amount = size - pos; + for(i = 0; i != amount; ++i) result ^= ((unsigned)data[pos + i] << (i * 8u)); + } + return result & HASH_BIT_MASK; +} + +static unsigned countZeros(const unsigned char* data, size_t size, size_t pos) { + const unsigned char* start = data + pos; + const unsigned char* end = start + MAX_SUPPORTED_DEFLATE_LENGTH; + if(end > data + size) end = data + size; + data = start; + while(data != end && *data == 0) ++data; + /*subtracting two addresses returned as 32-bit number (max value is MAX_SUPPORTED_DEFLATE_LENGTH)*/ + return (unsigned)(data - start); +} + +/*wpos = pos & (windowsize - 1)*/ +static void updateHashChain(Hash* hash, size_t wpos, unsigned hashval, unsigned short numzeros) { + hash->val[wpos] = (int)hashval; + if(hash->head[hashval] != -1) hash->chain[wpos] = hash->head[hashval]; + hash->head[hashval] = (int)wpos; + + hash->zeros[wpos] = numzeros; + if(hash->headz[numzeros] != -1) hash->chainz[wpos] = hash->headz[numzeros]; + hash->headz[numzeros] = (int)wpos; +} + +/* +LZ77-encode the data. Return value is error code. The input are raw bytes, the output +is in the form of unsigned integers with codes representing for example literal bytes, or +length/distance pairs. +It uses a hash table technique to let it encode faster. When doing LZ77 encoding, a +sliding window (of windowsize) is used, and all past bytes in that window can be used as +the "dictionary". A brute force search through all possible distances would be slow, and +this hash technique is one out of several ways to speed this up. +*/ +static unsigned encodeLZ77(uivector* out, Hash* hash, + const unsigned char* in, size_t inpos, size_t insize, unsigned windowsize, + unsigned minmatch, unsigned nicematch, unsigned lazymatching) { + size_t pos; + unsigned i, error = 0; + /*for large window lengths, assume the user wants no compression loss. Otherwise, max hash chain length speedup.*/ + unsigned maxchainlength = windowsize >= 8192 ? windowsize : windowsize / 8u; + unsigned maxlazymatch = windowsize >= 8192 ? MAX_SUPPORTED_DEFLATE_LENGTH : 64; + + unsigned usezeros = 1; /*not sure if setting it to false for windowsize < 8192 is better or worse*/ + unsigned numzeros = 0; + + unsigned offset; /*the offset represents the distance in LZ77 terminology*/ + unsigned length; + unsigned lazy = 0; + unsigned lazylength = 0, lazyoffset = 0; + unsigned hashval; + unsigned current_offset, current_length; + unsigned prev_offset; + const unsigned char *lastptr, *foreptr, *backptr; + unsigned hashpos; + + if(windowsize == 0 || windowsize > 32768) return 60; /*error: windowsize smaller/larger than allowed*/ + if((windowsize & (windowsize - 1)) != 0) return 90; /*error: must be power of two*/ + + if(nicematch > MAX_SUPPORTED_DEFLATE_LENGTH) nicematch = MAX_SUPPORTED_DEFLATE_LENGTH; + + for(pos = inpos; pos < insize; ++pos) { + size_t wpos = pos & (windowsize - 1); /*position for in 'circular' hash buffers*/ + unsigned chainlength = 0; + + hashval = getHash(in, insize, pos); + + if(usezeros && hashval == 0) { + if(numzeros == 0) numzeros = countZeros(in, insize, pos); + else if(pos + numzeros > insize || in[pos + numzeros - 1] != 0) --numzeros; + } else { + numzeros = 0; + } + + updateHashChain(hash, wpos, hashval, numzeros); + + /*the length and offset found for the current position*/ + length = 0; + offset = 0; + + hashpos = hash->chain[wpos]; + + lastptr = &in[insize < pos + MAX_SUPPORTED_DEFLATE_LENGTH ? insize : pos + MAX_SUPPORTED_DEFLATE_LENGTH]; + + /*search for the longest string*/ + prev_offset = 0; + for(;;) { + if(chainlength++ >= maxchainlength) break; + current_offset = (unsigned)(hashpos <= wpos ? wpos - hashpos : wpos - hashpos + windowsize); + + if(current_offset < prev_offset) break; /*stop when went completely around the circular buffer*/ + prev_offset = current_offset; + if(current_offset > 0) { + /*test the next characters*/ + foreptr = &in[pos]; + backptr = &in[pos - current_offset]; + + /*common case in PNGs is lots of zeros. Quickly skip over them as a speedup*/ + if(numzeros >= 3) { + unsigned skip = hash->zeros[hashpos]; + if(skip > numzeros) skip = numzeros; + backptr += skip; + foreptr += skip; + } + + while(foreptr != lastptr && *backptr == *foreptr) /*maximum supported length by deflate is max length*/ { + ++backptr; + ++foreptr; + } + current_length = (unsigned)(foreptr - &in[pos]); + + if(current_length > length) { + length = current_length; /*the longest length*/ + offset = current_offset; /*the offset that is related to this longest length*/ + /*jump out once a length of max length is found (speed gain). This also jumps + out if length is MAX_SUPPORTED_DEFLATE_LENGTH*/ + if(current_length >= nicematch) break; + } + } + + if(hashpos == hash->chain[hashpos]) break; + + if(numzeros >= 3 && length > numzeros) { + hashpos = hash->chainz[hashpos]; + if(hash->zeros[hashpos] != numzeros) break; + } else { + hashpos = hash->chain[hashpos]; + /*outdated hash value, happens if particular value was not encountered in whole last window*/ + if(hash->val[hashpos] != (int)hashval) break; + } + } + + if(lazymatching) { + if(!lazy && length >= 3 && length <= maxlazymatch && length < MAX_SUPPORTED_DEFLATE_LENGTH) { + lazy = 1; + lazylength = length; + lazyoffset = offset; + continue; /*try the next byte*/ + } + if(lazy) { + lazy = 0; + if(pos == 0) ERROR_BREAK(81); + if(length > lazylength + 1) { + /*push the previous character as literal*/ + if(!uivector_push_back(out, in[pos - 1])) ERROR_BREAK(83 /*alloc fail*/); + } else { + length = lazylength; + offset = lazyoffset; + hash->head[hashval] = -1; /*the same hashchain update will be done, this ensures no wrong alteration*/ + hash->headz[numzeros] = -1; /*idem*/ + --pos; + } + } + } + if(length >= 3 && offset > windowsize) ERROR_BREAK(86 /*too big (or overflown negative) offset*/); + + /*encode it as length/distance pair or literal value*/ + if(length < 3) /*only lengths of 3 or higher are supported as length/distance pair*/ { + if(!uivector_push_back(out, in[pos])) ERROR_BREAK(83 /*alloc fail*/); + } else if(length < minmatch || (length == 3 && offset > 4096)) { + /*compensate for the fact that longer offsets have more extra bits, a + length of only 3 may be not worth it then*/ + if(!uivector_push_back(out, in[pos])) ERROR_BREAK(83 /*alloc fail*/); + } else { + addLengthDistance(out, length, offset); + for(i = 1; i < length; ++i) { + ++pos; + wpos = pos & (windowsize - 1); + hashval = getHash(in, insize, pos); + if(usezeros && hashval == 0) { + if(numzeros == 0) numzeros = countZeros(in, insize, pos); + else if(pos + numzeros > insize || in[pos + numzeros - 1] != 0) --numzeros; + } else { + numzeros = 0; + } + updateHashChain(hash, wpos, hashval, numzeros); + } + } + } /*end of the loop through each character of input*/ + + return error; +} + +/* /////////////////////////////////////////////////////////////////////////// */ + +static unsigned deflateNoCompression(ucvector* out, const unsigned char* data, size_t datasize) { + /*non compressed deflate block data: 1 bit BFINAL,2 bits BTYPE,(5 bits): it jumps to start of next byte, + 2 bytes LEN, 2 bytes NLEN, LEN bytes literal DATA*/ + + size_t i, numdeflateblocks = (datasize + 65534u) / 65535u; + unsigned datapos = 0; + for(i = 0; i != numdeflateblocks; ++i) { + unsigned BFINAL, BTYPE, LEN, NLEN; + unsigned char firstbyte; + size_t pos = out->size; + + BFINAL = (i == numdeflateblocks - 1); + BTYPE = 0; + + LEN = 65535; + if(datasize - datapos < 65535u) LEN = (unsigned)datasize - datapos; + NLEN = 65535 - LEN; + + if(!ucvector_resize(out, out->size + LEN + 5)) return 83; /*alloc fail*/ + + firstbyte = (unsigned char)(BFINAL + ((BTYPE & 1u) << 1u) + ((BTYPE & 2u) << 1u)); + out->data[pos + 0] = firstbyte; + out->data[pos + 1] = (unsigned char)(LEN & 255); + out->data[pos + 2] = (unsigned char)(LEN >> 8u); + out->data[pos + 3] = (unsigned char)(NLEN & 255); + out->data[pos + 4] = (unsigned char)(NLEN >> 8u); + lodepng_memcpy(out->data + pos + 5, data + datapos, LEN); + datapos += LEN; + } + + return 0; +} + +/* +write the lz77-encoded data, which has lit, len and dist codes, to compressed stream using huffman trees. +tree_ll: the tree for lit and len codes. +tree_d: the tree for distance codes. +*/ +static void writeLZ77data(LodePNGBitWriter* writer, const uivector* lz77_encoded, + const HuffmanTree* tree_ll, const HuffmanTree* tree_d) { + size_t i = 0; + for(i = 0; i != lz77_encoded->size; ++i) { + unsigned val = lz77_encoded->data[i]; + writeBitsReversed(writer, tree_ll->codes[val], tree_ll->lengths[val]); + if(val > 256) /*for a length code, 3 more things have to be added*/ { + unsigned length_index = val - FIRST_LENGTH_CODE_INDEX; + unsigned n_length_extra_bits = LENGTHEXTRA[length_index]; + unsigned length_extra_bits = lz77_encoded->data[++i]; + + unsigned distance_code = lz77_encoded->data[++i]; + + unsigned distance_index = distance_code; + unsigned n_distance_extra_bits = DISTANCEEXTRA[distance_index]; + unsigned distance_extra_bits = lz77_encoded->data[++i]; + + writeBits(writer, length_extra_bits, n_length_extra_bits); + writeBitsReversed(writer, tree_d->codes[distance_code], tree_d->lengths[distance_code]); + writeBits(writer, distance_extra_bits, n_distance_extra_bits); + } + } +} + +/*Deflate for a block of type "dynamic", that is, with freely, optimally, created huffman trees*/ +static unsigned deflateDynamic(LodePNGBitWriter* writer, Hash* hash, + const unsigned char* data, size_t datapos, size_t dataend, + const LodePNGCompressSettings* settings, unsigned final) { + unsigned error = 0; + + /* + A block is compressed as follows: The PNG data is lz77 encoded, resulting in + literal bytes and length/distance pairs. This is then huffman compressed with + two huffman trees. One huffman tree is used for the lit and len values ("ll"), + another huffman tree is used for the dist values ("d"). These two trees are + stored using their code lengths, and to compress even more these code lengths + are also run-length encoded and huffman compressed. This gives a huffman tree + of code lengths "cl". The code lengths used to describe this third tree are + the code length code lengths ("clcl"). + */ + + /*The lz77 encoded data, represented with integers since there will also be length and distance codes in it*/ + uivector lz77_encoded; + HuffmanTree tree_ll; /*tree for lit,len values*/ + HuffmanTree tree_d; /*tree for distance codes*/ + HuffmanTree tree_cl; /*tree for encoding the code lengths representing tree_ll and tree_d*/ + unsigned* frequencies_ll = 0; /*frequency of lit,len codes*/ + unsigned* frequencies_d = 0; /*frequency of dist codes*/ + unsigned* frequencies_cl = 0; /*frequency of code length codes*/ + unsigned* bitlen_lld = 0; /*lit,len,dist code lengths (int bits), literally (without repeat codes).*/ + unsigned* bitlen_lld_e = 0; /*bitlen_lld encoded with repeat codes (this is a rudimentary run length compression)*/ + size_t datasize = dataend - datapos; + + /* + If we could call "bitlen_cl" the the code length code lengths ("clcl"), that is the bit lengths of codes to represent + tree_cl in CLCL_ORDER, then due to the huffman compression of huffman tree representations ("two levels"), there are + some analogies: + bitlen_lld is to tree_cl what data is to tree_ll and tree_d. + bitlen_lld_e is to bitlen_lld what lz77_encoded is to data. + bitlen_cl is to bitlen_lld_e what bitlen_lld is to lz77_encoded. + */ + + unsigned BFINAL = final; + size_t i; + size_t numcodes_ll, numcodes_d, numcodes_lld, numcodes_lld_e, numcodes_cl; + unsigned HLIT, HDIST, HCLEN; + + uivector_init(&lz77_encoded); + HuffmanTree_init(&tree_ll); + HuffmanTree_init(&tree_d); + HuffmanTree_init(&tree_cl); + /* could fit on stack, but >1KB is on the larger side so allocate instead */ + frequencies_ll = (unsigned*)lodepng_malloc(286 * sizeof(*frequencies_ll)); + frequencies_d = (unsigned*)lodepng_malloc(30 * sizeof(*frequencies_d)); + frequencies_cl = (unsigned*)lodepng_malloc(NUM_CODE_LENGTH_CODES * sizeof(*frequencies_cl)); + + if(!frequencies_ll || !frequencies_d || !frequencies_cl) error = 83; /*alloc fail*/ + + /*This while loop never loops due to a break at the end, it is here to + allow breaking out of it to the cleanup phase on error conditions.*/ + while(!error) { + lodepng_memset(frequencies_ll, 0, 286 * sizeof(*frequencies_ll)); + lodepng_memset(frequencies_d, 0, 30 * sizeof(*frequencies_d)); + lodepng_memset(frequencies_cl, 0, NUM_CODE_LENGTH_CODES * sizeof(*frequencies_cl)); + + if(settings->use_lz77) { + error = encodeLZ77(&lz77_encoded, hash, data, datapos, dataend, settings->windowsize, + settings->minmatch, settings->nicematch, settings->lazymatching); + if(error) break; + } else { + if(!uivector_resize(&lz77_encoded, datasize)) ERROR_BREAK(83 /*alloc fail*/); + for(i = datapos; i < dataend; ++i) lz77_encoded.data[i - datapos] = data[i]; /*no LZ77, but still will be Huffman compressed*/ + } + + /*Count the frequencies of lit, len and dist codes*/ + for(i = 0; i != lz77_encoded.size; ++i) { + unsigned symbol = lz77_encoded.data[i]; + ++frequencies_ll[symbol]; + if(symbol > 256) { + unsigned dist = lz77_encoded.data[i + 2]; + ++frequencies_d[dist]; + i += 3; + } + } + frequencies_ll[256] = 1; /*there will be exactly 1 end code, at the end of the block*/ + + /*Make both huffman trees, one for the lit and len codes, one for the dist codes*/ + error = HuffmanTree_makeFromFrequencies(&tree_ll, frequencies_ll, 257, 286, 15); + if(error) break; + /*2, not 1, is chosen for mincodes: some buggy PNG decoders require at least 2 symbols in the dist tree*/ + error = HuffmanTree_makeFromFrequencies(&tree_d, frequencies_d, 2, 30, 15); + if(error) break; + + numcodes_ll = LODEPNG_MIN(tree_ll.numcodes, 286); + numcodes_d = LODEPNG_MIN(tree_d.numcodes, 30); + /*store the code lengths of both generated trees in bitlen_lld*/ + numcodes_lld = numcodes_ll + numcodes_d; + bitlen_lld = (unsigned*)lodepng_malloc(numcodes_lld * sizeof(*bitlen_lld)); + /*numcodes_lld_e never needs more size than bitlen_lld*/ + bitlen_lld_e = (unsigned*)lodepng_malloc(numcodes_lld * sizeof(*bitlen_lld_e)); + if(!bitlen_lld || !bitlen_lld_e) ERROR_BREAK(83); /*alloc fail*/ + numcodes_lld_e = 0; + + for(i = 0; i != numcodes_ll; ++i) bitlen_lld[i] = tree_ll.lengths[i]; + for(i = 0; i != numcodes_d; ++i) bitlen_lld[numcodes_ll + i] = tree_d.lengths[i]; + + /*run-length compress bitlen_ldd into bitlen_lld_e by using repeat codes 16 (copy length 3-6 times), + 17 (3-10 zeroes), 18 (11-138 zeroes)*/ + for(i = 0; i != numcodes_lld; ++i) { + unsigned j = 0; /*amount of repetitions*/ + while(i + j + 1 < numcodes_lld && bitlen_lld[i + j + 1] == bitlen_lld[i]) ++j; + + if(bitlen_lld[i] == 0 && j >= 2) /*repeat code for zeroes*/ { + ++j; /*include the first zero*/ + if(j <= 10) /*repeat code 17 supports max 10 zeroes*/ { + bitlen_lld_e[numcodes_lld_e++] = 17; + bitlen_lld_e[numcodes_lld_e++] = j - 3; + } else /*repeat code 18 supports max 138 zeroes*/ { + if(j > 138) j = 138; + bitlen_lld_e[numcodes_lld_e++] = 18; + bitlen_lld_e[numcodes_lld_e++] = j - 11; + } + i += (j - 1); + } else if(j >= 3) /*repeat code for value other than zero*/ { + size_t k; + unsigned num = j / 6u, rest = j % 6u; + bitlen_lld_e[numcodes_lld_e++] = bitlen_lld[i]; + for(k = 0; k < num; ++k) { + bitlen_lld_e[numcodes_lld_e++] = 16; + bitlen_lld_e[numcodes_lld_e++] = 6 - 3; + } + if(rest >= 3) { + bitlen_lld_e[numcodes_lld_e++] = 16; + bitlen_lld_e[numcodes_lld_e++] = rest - 3; + } + else j -= rest; + i += j; + } else /*too short to benefit from repeat code*/ { + bitlen_lld_e[numcodes_lld_e++] = bitlen_lld[i]; + } + } + + /*generate tree_cl, the huffmantree of huffmantrees*/ + for(i = 0; i != numcodes_lld_e; ++i) { + ++frequencies_cl[bitlen_lld_e[i]]; + /*after a repeat code come the bits that specify the number of repetitions, + those don't need to be in the frequencies_cl calculation*/ + if(bitlen_lld_e[i] >= 16) ++i; + } + + error = HuffmanTree_makeFromFrequencies(&tree_cl, frequencies_cl, + NUM_CODE_LENGTH_CODES, NUM_CODE_LENGTH_CODES, 7); + if(error) break; + + /*compute amount of code-length-code-lengths to output*/ + numcodes_cl = NUM_CODE_LENGTH_CODES; + /*trim zeros at the end (using CLCL_ORDER), but minimum size must be 4 (see HCLEN below)*/ + while(numcodes_cl > 4u && tree_cl.lengths[CLCL_ORDER[numcodes_cl - 1u]] == 0) { + numcodes_cl--; + } + + /* + Write everything into the output + + After the BFINAL and BTYPE, the dynamic block consists out of the following: + - 5 bits HLIT, 5 bits HDIST, 4 bits HCLEN + - (HCLEN+4)*3 bits code lengths of code length alphabet + - HLIT + 257 code lengths of lit/length alphabet (encoded using the code length + alphabet, + possible repetition codes 16, 17, 18) + - HDIST + 1 code lengths of distance alphabet (encoded using the code length + alphabet, + possible repetition codes 16, 17, 18) + - compressed data + - 256 (end code) + */ + + /*Write block type*/ + writeBits(writer, BFINAL, 1); + writeBits(writer, 0, 1); /*first bit of BTYPE "dynamic"*/ + writeBits(writer, 1, 1); /*second bit of BTYPE "dynamic"*/ + + /*write the HLIT, HDIST and HCLEN values*/ + /*all three sizes take trimmed ending zeroes into account, done either by HuffmanTree_makeFromFrequencies + or in the loop for numcodes_cl above, which saves space. */ + HLIT = (unsigned)(numcodes_ll - 257); + HDIST = (unsigned)(numcodes_d - 1); + HCLEN = (unsigned)(numcodes_cl - 4); + writeBits(writer, HLIT, 5); + writeBits(writer, HDIST, 5); + writeBits(writer, HCLEN, 4); + + /*write the code lengths of the code length alphabet ("bitlen_cl")*/ + for(i = 0; i != numcodes_cl; ++i) writeBits(writer, tree_cl.lengths[CLCL_ORDER[i]], 3); + + /*write the lengths of the lit/len AND the dist alphabet*/ + for(i = 0; i != numcodes_lld_e; ++i) { + writeBitsReversed(writer, tree_cl.codes[bitlen_lld_e[i]], tree_cl.lengths[bitlen_lld_e[i]]); + /*extra bits of repeat codes*/ + if(bitlen_lld_e[i] == 16) writeBits(writer, bitlen_lld_e[++i], 2); + else if(bitlen_lld_e[i] == 17) writeBits(writer, bitlen_lld_e[++i], 3); + else if(bitlen_lld_e[i] == 18) writeBits(writer, bitlen_lld_e[++i], 7); + } + + /*write the compressed data symbols*/ + writeLZ77data(writer, &lz77_encoded, &tree_ll, &tree_d); + /*error: the length of the end code 256 must be larger than 0*/ + if(tree_ll.lengths[256] == 0) ERROR_BREAK(64); + + /*write the end code*/ + writeBitsReversed(writer, tree_ll.codes[256], tree_ll.lengths[256]); + + break; /*end of error-while*/ + } + + /*cleanup*/ + uivector_cleanup(&lz77_encoded); + HuffmanTree_cleanup(&tree_ll); + HuffmanTree_cleanup(&tree_d); + HuffmanTree_cleanup(&tree_cl); + lodepng_free(frequencies_ll); + lodepng_free(frequencies_d); + lodepng_free(frequencies_cl); + lodepng_free(bitlen_lld); + lodepng_free(bitlen_lld_e); + + return error; +} + +static unsigned deflateFixed(LodePNGBitWriter* writer, Hash* hash, + const unsigned char* data, + size_t datapos, size_t dataend, + const LodePNGCompressSettings* settings, unsigned final) { + HuffmanTree tree_ll; /*tree for literal values and length codes*/ + HuffmanTree tree_d; /*tree for distance codes*/ + + unsigned BFINAL = final; + unsigned error = 0; + size_t i; + + HuffmanTree_init(&tree_ll); + HuffmanTree_init(&tree_d); + + error = generateFixedLitLenTree(&tree_ll); + if(!error) error = generateFixedDistanceTree(&tree_d); + + if(!error) { + writeBits(writer, BFINAL, 1); + writeBits(writer, 1, 1); /*first bit of BTYPE*/ + writeBits(writer, 0, 1); /*second bit of BTYPE*/ + + if(settings->use_lz77) /*LZ77 encoded*/ { + uivector lz77_encoded; + uivector_init(&lz77_encoded); + error = encodeLZ77(&lz77_encoded, hash, data, datapos, dataend, settings->windowsize, + settings->minmatch, settings->nicematch, settings->lazymatching); + if(!error) writeLZ77data(writer, &lz77_encoded, &tree_ll, &tree_d); + uivector_cleanup(&lz77_encoded); + } else /*no LZ77, but still will be Huffman compressed*/ { + for(i = datapos; i < dataend; ++i) { + writeBitsReversed(writer, tree_ll.codes[data[i]], tree_ll.lengths[data[i]]); + } + } + /*add END code*/ + if(!error) writeBitsReversed(writer,tree_ll.codes[256], tree_ll.lengths[256]); + } + + /*cleanup*/ + HuffmanTree_cleanup(&tree_ll); + HuffmanTree_cleanup(&tree_d); + + return error; +} + +static unsigned lodepng_deflatev(ucvector* out, const unsigned char* in, size_t insize, + const LodePNGCompressSettings* settings) { + unsigned error = 0; + size_t i, blocksize, numdeflateblocks; + Hash hash; + LodePNGBitWriter writer; + + LodePNGBitWriter_init(&writer, out); + + if(settings->btype > 2) return 61; + else if(settings->btype == 0) return deflateNoCompression(out, in, insize); + else if(settings->btype == 1) blocksize = insize; + else /*if(settings->btype == 2)*/ { + /*on PNGs, deflate blocks of 65-262k seem to give most dense encoding*/ + blocksize = insize / 8u + 8; + if(blocksize < 65536) blocksize = 65536; + if(blocksize > 262144) blocksize = 262144; + } + + numdeflateblocks = (insize + blocksize - 1) / blocksize; + if(numdeflateblocks == 0) numdeflateblocks = 1; + + error = hash_init(&hash, settings->windowsize); + + if(!error) { + for(i = 0; i != numdeflateblocks && !error; ++i) { + unsigned final = (i == numdeflateblocks - 1); + size_t start = i * blocksize; + size_t end = start + blocksize; + if(end > insize) end = insize; + + if(settings->btype == 1) error = deflateFixed(&writer, &hash, in, start, end, settings, final); + else if(settings->btype == 2) error = deflateDynamic(&writer, &hash, in, start, end, settings, final); + } + } + + hash_cleanup(&hash); + + return error; +} + +unsigned lodepng_deflate(unsigned char** out, size_t* outsize, + const unsigned char* in, size_t insize, + const LodePNGCompressSettings* settings) { + ucvector v = ucvector_init(*out, *outsize); + unsigned error = lodepng_deflatev(&v, in, insize, settings); + *out = v.data; + *outsize = v.size; + return error; +} + +static unsigned deflate(unsigned char** out, size_t* outsize, + const unsigned char* in, size_t insize, + const LodePNGCompressSettings* settings) { + if(settings->custom_deflate) { + unsigned error = settings->custom_deflate(out, outsize, in, insize, settings); + /*the custom deflate is allowed to have its own error codes, however, we translate it to code 111*/ + return error ? 111 : 0; + } else { + return lodepng_deflate(out, outsize, in, insize, settings); + } +} + +#endif /*LODEPNG_COMPILE_DECODER*/ + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / Adler32 / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +static unsigned update_adler32(unsigned adler, const unsigned char* data, unsigned len) { + unsigned s1 = adler & 0xffffu; + unsigned s2 = (adler >> 16u) & 0xffffu; + + while(len != 0u) { + unsigned i; + /*at least 5552 sums can be done before the sums overflow, saving a lot of module divisions*/ + unsigned amount = len > 5552u ? 5552u : len; + len -= amount; + for(i = 0; i != amount; ++i) { + s1 += (*data++); + s2 += s1; + } + s1 %= 65521u; + s2 %= 65521u; + } + + return (s2 << 16u) | s1; +} + +/*Return the adler32 of the bytes data[0..len-1]*/ +static unsigned adler32(const unsigned char* data, unsigned len) { + return update_adler32(1u, data, len); +} + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / Zlib / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +#ifdef LODEPNG_COMPILE_DECODER + +static unsigned lodepng_zlib_decompressv(ucvector* out, + const unsigned char* in, size_t insize, + const LodePNGDecompressSettings* settings) { + unsigned error = 0; + unsigned CM, CINFO, FDICT; + + if(insize < 2) return 53; /*error, size of zlib data too small*/ + /*read information from zlib header*/ + if((in[0] * 256 + in[1]) % 31 != 0) { + /*error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way*/ + return 24; + } + + CM = in[0] & 15; + CINFO = (in[0] >> 4) & 15; + /*FCHECK = in[1] & 31;*/ /*FCHECK is already tested above*/ + FDICT = (in[1] >> 5) & 1; + /*FLEVEL = (in[1] >> 6) & 3;*/ /*FLEVEL is not used here*/ + + if(CM != 8 || CINFO > 7) { + /*error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec*/ + return 25; + } + if(FDICT != 0) { + /*error: the specification of PNG says about the zlib stream: + "The additional flags shall not specify a preset dictionary."*/ + return 26; + } + + error = inflatev(out, in + 2, insize - 2, settings); + if(error) return error; + + if(!settings->ignore_adler32) { + unsigned ADLER32 = lodepng_read32bitInt(&in[insize - 4]); + unsigned checksum = adler32(out->data, (unsigned)(out->size)); + if(checksum != ADLER32) return 58; /*error, adler checksum not correct, data must be corrupted*/ + } + + return 0; /*no error*/ +} + + +unsigned lodepng_zlib_decompress(unsigned char** out, size_t* outsize, const unsigned char* in, + size_t insize, const LodePNGDecompressSettings* settings) { + ucvector v = ucvector_init(*out, *outsize); + unsigned error = lodepng_zlib_decompressv(&v, in, insize, settings); + *out = v.data; + *outsize = v.size; + return error; +} + +/*expected_size is expected output size, to avoid intermediate allocations. Set to 0 if not known. */ +static unsigned zlib_decompress(unsigned char** out, size_t* outsize, size_t expected_size, + const unsigned char* in, size_t insize, const LodePNGDecompressSettings* settings) { + unsigned error; + if(settings->custom_zlib) { + error = settings->custom_zlib(out, outsize, in, insize, settings); + if(error) { + /*the custom zlib is allowed to have its own error codes, however, we translate it to code 110*/ + error = 110; + /*if there's a max output size, and the custom zlib returned error, then indicate that error instead*/ + if(settings->max_output_size && *outsize > settings->max_output_size) error = 109; + } + } else { + ucvector v = ucvector_init(*out, *outsize); + if(expected_size) { + /*reserve the memory to avoid intermediate reallocations*/ + ucvector_resize(&v, *outsize + expected_size); + v.size = *outsize; + } + error = lodepng_zlib_decompressv(&v, in, insize, settings); + *out = v.data; + *outsize = v.size; + } + return error; +} + +#endif /*LODEPNG_COMPILE_DECODER*/ + +#ifdef LODEPNG_COMPILE_ENCODER + +unsigned lodepng_zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in, + size_t insize, const LodePNGCompressSettings* settings) { + size_t i; + unsigned error; + unsigned char* deflatedata = 0; + size_t deflatesize = 0; + + error = deflate(&deflatedata, &deflatesize, in, insize, settings); + + *out = NULL; + *outsize = 0; + if(!error) { + *outsize = deflatesize + 6; + *out = (unsigned char*)lodepng_malloc(*outsize); + if(!*out) error = 83; /*alloc fail*/ + } + + if(!error) { + unsigned ADLER32 = adler32(in, (unsigned)insize); + /*zlib data: 1 byte CMF (CM+CINFO), 1 byte FLG, deflate data, 4 byte ADLER32 checksum of the Decompressed data*/ + unsigned CMF = 120; /*0b01111000: CM 8, CINFO 7. With CINFO 7, any window size up to 32768 can be used.*/ + unsigned FLEVEL = 0; + unsigned FDICT = 0; + unsigned CMFFLG = 256 * CMF + FDICT * 32 + FLEVEL * 64; + unsigned FCHECK = 31 - CMFFLG % 31; + CMFFLG += FCHECK; + + (*out)[0] = (unsigned char)(CMFFLG >> 8); + (*out)[1] = (unsigned char)(CMFFLG & 255); + for(i = 0; i != deflatesize; ++i) (*out)[i + 2] = deflatedata[i]; + lodepng_set32bitInt(&(*out)[*outsize - 4], ADLER32); + } + + lodepng_free(deflatedata); + return error; +} + +/* compress using the default or custom zlib function */ +static unsigned zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in, + size_t insize, const LodePNGCompressSettings* settings) { + if(settings->custom_zlib) { + unsigned error = settings->custom_zlib(out, outsize, in, insize, settings); + /*the custom zlib is allowed to have its own error codes, however, we translate it to code 111*/ + return error ? 111 : 0; + } else { + return lodepng_zlib_compress(out, outsize, in, insize, settings); + } +} + +#endif /*LODEPNG_COMPILE_ENCODER*/ + +#else /*no LODEPNG_COMPILE_ZLIB*/ + +#ifdef LODEPNG_COMPILE_DECODER +static unsigned zlib_decompress(unsigned char** out, size_t* outsize, size_t expected_size, + const unsigned char* in, size_t insize, const LodePNGDecompressSettings* settings) { + if(!settings->custom_zlib) return 87; /*no custom zlib function provided */ + (void)expected_size; + return settings->custom_zlib(out, outsize, in, insize, settings); +} +#endif /*LODEPNG_COMPILE_DECODER*/ +#ifdef LODEPNG_COMPILE_ENCODER +static unsigned zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in, + size_t insize, const LodePNGCompressSettings* settings) { + if(!settings->custom_zlib) return 87; /*no custom zlib function provided */ + return settings->custom_zlib(out, outsize, in, insize, settings); +} +#endif /*LODEPNG_COMPILE_ENCODER*/ + +#endif /*LODEPNG_COMPILE_ZLIB*/ + +/* ////////////////////////////////////////////////////////////////////////// */ + +#ifdef LODEPNG_COMPILE_ENCODER + +/*this is a good tradeoff between speed and compression ratio*/ +#define DEFAULT_WINDOWSIZE 2048 + +void lodepng_compress_settings_init(LodePNGCompressSettings* settings) { + /*compress with dynamic huffman tree (not in the mathematical sense, just not the predefined one)*/ + settings->btype = 2; + settings->use_lz77 = 1; + settings->windowsize = DEFAULT_WINDOWSIZE; + settings->minmatch = 3; + settings->nicematch = 128; + settings->lazymatching = 1; + + settings->custom_zlib = 0; + settings->custom_deflate = 0; + settings->custom_context = 0; +} + +const LodePNGCompressSettings lodepng_default_compress_settings = {2, 1, DEFAULT_WINDOWSIZE, 3, 128, 1, 0, 0, 0}; + + +#endif /*LODEPNG_COMPILE_ENCODER*/ + +#ifdef LODEPNG_COMPILE_DECODER + +void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings) { + settings->ignore_adler32 = 0; + settings->ignore_nlen = 0; + settings->max_output_size = 0; + + settings->custom_zlib = 0; + settings->custom_inflate = 0; + settings->custom_context = 0; +} + +const LodePNGDecompressSettings lodepng_default_decompress_settings = {0, 0, 0, 0, 0, 0}; + +#endif /*LODEPNG_COMPILE_DECODER*/ + +/* ////////////////////////////////////////////////////////////////////////// */ +/* ////////////////////////////////////////////////////////////////////////// */ +/* // End of Zlib related code. Begin of PNG related code. // */ +/* ////////////////////////////////////////////////////////////////////////// */ +/* ////////////////////////////////////////////////////////////////////////// */ + +#ifdef LODEPNG_COMPILE_PNG + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / CRC32 / */ +/* ////////////////////////////////////////////////////////////////////////// */ + + +#ifndef LODEPNG_NO_COMPILE_CRC +/* CRC polynomial: 0xedb88320 */ +static unsigned lodepng_crc32_table[256] = { + 0u, 1996959894u, 3993919788u, 2567524794u, 124634137u, 1886057615u, 3915621685u, 2657392035u, + 249268274u, 2044508324u, 3772115230u, 2547177864u, 162941995u, 2125561021u, 3887607047u, 2428444049u, + 498536548u, 1789927666u, 4089016648u, 2227061214u, 450548861u, 1843258603u, 4107580753u, 2211677639u, + 325883990u, 1684777152u, 4251122042u, 2321926636u, 335633487u, 1661365465u, 4195302755u, 2366115317u, + 997073096u, 1281953886u, 3579855332u, 2724688242u, 1006888145u, 1258607687u, 3524101629u, 2768942443u, + 901097722u, 1119000684u, 3686517206u, 2898065728u, 853044451u, 1172266101u, 3705015759u, 2882616665u, + 651767980u, 1373503546u, 3369554304u, 3218104598u, 565507253u, 1454621731u, 3485111705u, 3099436303u, + 671266974u, 1594198024u, 3322730930u, 2970347812u, 795835527u, 1483230225u, 3244367275u, 3060149565u, + 1994146192u, 31158534u, 2563907772u, 4023717930u, 1907459465u, 112637215u, 2680153253u, 3904427059u, + 2013776290u, 251722036u, 2517215374u, 3775830040u, 2137656763u, 141376813u, 2439277719u, 3865271297u, + 1802195444u, 476864866u, 2238001368u, 4066508878u, 1812370925u, 453092731u, 2181625025u, 4111451223u, + 1706088902u, 314042704u, 2344532202u, 4240017532u, 1658658271u, 366619977u, 2362670323u, 4224994405u, + 1303535960u, 984961486u, 2747007092u, 3569037538u, 1256170817u, 1037604311u, 2765210733u, 3554079995u, + 1131014506u, 879679996u, 2909243462u, 3663771856u, 1141124467u, 855842277u, 2852801631u, 3708648649u, + 1342533948u, 654459306u, 3188396048u, 3373015174u, 1466479909u, 544179635u, 3110523913u, 3462522015u, + 1591671054u, 702138776u, 2966460450u, 3352799412u, 1504918807u, 783551873u, 3082640443u, 3233442989u, + 3988292384u, 2596254646u, 62317068u, 1957810842u, 3939845945u, 2647816111u, 81470997u, 1943803523u, + 3814918930u, 2489596804u, 225274430u, 2053790376u, 3826175755u, 2466906013u, 167816743u, 2097651377u, + 4027552580u, 2265490386u, 503444072u, 1762050814u, 4150417245u, 2154129355u, 426522225u, 1852507879u, + 4275313526u, 2312317920u, 282753626u, 1742555852u, 4189708143u, 2394877945u, 397917763u, 1622183637u, + 3604390888u, 2714866558u, 953729732u, 1340076626u, 3518719985u, 2797360999u, 1068828381u, 1219638859u, + 3624741850u, 2936675148u, 906185462u, 1090812512u, 3747672003u, 2825379669u, 829329135u, 1181335161u, + 3412177804u, 3160834842u, 628085408u, 1382605366u, 3423369109u, 3138078467u, 570562233u, 1426400815u, + 3317316542u, 2998733608u, 733239954u, 1555261956u, 3268935591u, 3050360625u, 752459403u, 1541320221u, + 2607071920u, 3965973030u, 1969922972u, 40735498u, 2617837225u, 3943577151u, 1913087877u, 83908371u, + 2512341634u, 3803740692u, 2075208622u, 213261112u, 2463272603u, 3855990285u, 2094854071u, 198958881u, + 2262029012u, 4057260610u, 1759359992u, 534414190u, 2176718541u, 4139329115u, 1873836001u, 414664567u, + 2282248934u, 4279200368u, 1711684554u, 285281116u, 2405801727u, 4167216745u, 1634467795u, 376229701u, + 2685067896u, 3608007406u, 1308918612u, 956543938u, 2808555105u, 3495958263u, 1231636301u, 1047427035u, + 2932959818u, 3654703836u, 1088359270u, 936918000u, 2847714899u, 3736837829u, 1202900863u, 817233897u, + 3183342108u, 3401237130u, 1404277552u, 615818150u, 3134207493u, 3453421203u, 1423857449u, 601450431u, + 3009837614u, 3294710456u, 1567103746u, 711928724u, 3020668471u, 3272380065u, 1510334235u, 755167117u +}; + +/*Return the CRC of the bytes buf[0..len-1].*/ +unsigned lodepng_crc32(const unsigned char* data, size_t length) { + unsigned r = 0xffffffffu; + size_t i; + for(i = 0; i < length; ++i) { + r = lodepng_crc32_table[(r ^ data[i]) & 0xffu] ^ (r >> 8u); + } + return r ^ 0xffffffffu; +} +#else /* !LODEPNG_NO_COMPILE_CRC */ +unsigned lodepng_crc32(const unsigned char* data, size_t length); +#endif /* !LODEPNG_NO_COMPILE_CRC */ + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / Reading and writing PNG color channel bits / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +/* The color channel bits of less-than-8-bit pixels are read with the MSB of bytes first, +so LodePNGBitWriter and LodePNGBitReader can't be used for those. */ + +static unsigned char readBitFromReversedStream(size_t* bitpointer, const unsigned char* bitstream) { + unsigned char result = (unsigned char)((bitstream[(*bitpointer) >> 3] >> (7 - ((*bitpointer) & 0x7))) & 1); + ++(*bitpointer); + return result; +} + +/* TODO: make this faster */ +static unsigned readBitsFromReversedStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits) { + unsigned result = 0; + size_t i; + for(i = 0 ; i < nbits; ++i) { + result <<= 1u; + result |= (unsigned)readBitFromReversedStream(bitpointer, bitstream); + } + return result; +} + +static void setBitOfReversedStream(size_t* bitpointer, unsigned char* bitstream, unsigned char bit) { + /*the current bit in bitstream may be 0 or 1 for this to work*/ + if(bit == 0) bitstream[(*bitpointer) >> 3u] &= (unsigned char)(~(1u << (7u - ((*bitpointer) & 7u)))); + else bitstream[(*bitpointer) >> 3u] |= (1u << (7u - ((*bitpointer) & 7u))); + ++(*bitpointer); +} + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / PNG chunks / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +unsigned lodepng_chunk_length(const unsigned char* chunk) { + return lodepng_read32bitInt(&chunk[0]); +} + +void lodepng_chunk_type(char type[5], const unsigned char* chunk) { + unsigned i; + for(i = 0; i != 4; ++i) type[i] = (char)chunk[4 + i]; + type[4] = 0; /*null termination char*/ +} + +unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type) { + if(lodepng_strlen(type) != 4) return 0; + return (chunk[4] == type[0] && chunk[5] == type[1] && chunk[6] == type[2] && chunk[7] == type[3]); +} + +unsigned char lodepng_chunk_ancillary(const unsigned char* chunk) { + return((chunk[4] & 32) != 0); +} + +unsigned char lodepng_chunk_private(const unsigned char* chunk) { + return((chunk[6] & 32) != 0); +} + +unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk) { + return((chunk[7] & 32) != 0); +} + +unsigned char* lodepng_chunk_data(unsigned char* chunk) { + return &chunk[8]; +} + +const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk) { + return &chunk[8]; +} + +unsigned lodepng_chunk_check_crc(const unsigned char* chunk) { + unsigned length = lodepng_chunk_length(chunk); + unsigned CRC = lodepng_read32bitInt(&chunk[length + 8]); + /*the CRC is taken of the data and the 4 chunk type letters, not the length*/ + unsigned checksum = lodepng_crc32(&chunk[4], length + 4); + if(CRC != checksum) return 1; + else return 0; +} + +void lodepng_chunk_generate_crc(unsigned char* chunk) { + unsigned length = lodepng_chunk_length(chunk); + unsigned CRC = lodepng_crc32(&chunk[4], length + 4); + lodepng_set32bitInt(chunk + 8 + length, CRC); +} + +unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end) { + if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/ + if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47 + && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) { + /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */ + return chunk + 8; + } else { + size_t total_chunk_length; + unsigned char* result; + if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end; + result = chunk + total_chunk_length; + if(result < chunk) return end; /*pointer overflow*/ + return result; + } +} + +const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end) { + if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/ + if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47 + && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) { + /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */ + return chunk + 8; + } else { + size_t total_chunk_length; + const unsigned char* result; + if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end; + result = chunk + total_chunk_length; + if(result < chunk) return end; /*pointer overflow*/ + return result; + } +} + +unsigned char* lodepng_chunk_find(unsigned char* chunk, unsigned char* end, const char type[5]) { + for(;;) { + if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */ + if(lodepng_chunk_type_equals(chunk, type)) return chunk; + chunk = lodepng_chunk_next(chunk, end); + } +} + +const unsigned char* lodepng_chunk_find_const(const unsigned char* chunk, const unsigned char* end, const char type[5]) { + for(;;) { + if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */ + if(lodepng_chunk_type_equals(chunk, type)) return chunk; + chunk = lodepng_chunk_next_const(chunk, end); + } +} + +unsigned lodepng_chunk_append(unsigned char** out, size_t* outsize, const unsigned char* chunk) { + unsigned i; + size_t total_chunk_length, new_length; + unsigned char *chunk_start, *new_buffer; + + if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return 77; + if(lodepng_addofl(*outsize, total_chunk_length, &new_length)) return 77; + + new_buffer = (unsigned char*)lodepng_realloc(*out, new_length); + if(!new_buffer) return 83; /*alloc fail*/ + (*out) = new_buffer; + (*outsize) = new_length; + chunk_start = &(*out)[new_length - total_chunk_length]; + + for(i = 0; i != total_chunk_length; ++i) chunk_start[i] = chunk[i]; + + return 0; +} + +/*Sets length and name and allocates the space for data and crc but does not +set data or crc yet. Returns the start of the chunk in chunk. The start of +the data is at chunk + 8. To finalize chunk, add the data, then use +lodepng_chunk_generate_crc */ +static unsigned lodepng_chunk_init(unsigned char** chunk, + ucvector* out, + unsigned length, const char* type) { + size_t new_length = out->size; + if(lodepng_addofl(new_length, length, &new_length)) return 77; + if(lodepng_addofl(new_length, 12, &new_length)) return 77; + if(!ucvector_resize(out, new_length)) return 83; /*alloc fail*/ + *chunk = out->data + new_length - length - 12u; + + /*1: length*/ + lodepng_set32bitInt(*chunk, length); + + /*2: chunk name (4 letters)*/ + lodepng_memcpy(*chunk + 4, type, 4); + + return 0; +} + +/* like lodepng_chunk_create but with custom allocsize */ +static unsigned lodepng_chunk_createv(ucvector* out, + unsigned length, const char* type, const unsigned char* data) { + unsigned char* chunk; + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, length, type)); + + /*3: the data*/ + lodepng_memcpy(chunk + 8, data, length); + + /*4: CRC (of the chunkname characters and the data)*/ + lodepng_chunk_generate_crc(chunk); + + return 0; +} + +unsigned lodepng_chunk_create(unsigned char** out, size_t* outsize, + unsigned length, const char* type, const unsigned char* data) { + ucvector v = ucvector_init(*out, *outsize); + unsigned error = lodepng_chunk_createv(&v, length, type, data); + *out = v.data; + *outsize = v.size; + return error; +} + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / Color types, channels, bits / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +/*checks if the colortype is valid and the bitdepth bd is allowed for this colortype. +Return value is a LodePNG error code.*/ +static unsigned checkColorValidity(LodePNGColorType colortype, unsigned bd) { + switch(colortype) { + case LCT_GREY: if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) return 37; break; + case LCT_RGB: if(!( bd == 8 || bd == 16)) return 37; break; + case LCT_PALETTE: if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 )) return 37; break; + case LCT_GREY_ALPHA: if(!( bd == 8 || bd == 16)) return 37; break; + case LCT_RGBA: if(!( bd == 8 || bd == 16)) return 37; break; + case LCT_MAX_OCTET_VALUE: return 31; /* invalid color type */ + default: return 31; /* invalid color type */ + } + return 0; /*allowed color type / bits combination*/ +} + +static unsigned getNumColorChannels(LodePNGColorType colortype) { + switch(colortype) { + case LCT_GREY: return 1; + case LCT_RGB: return 3; + case LCT_PALETTE: return 1; + case LCT_GREY_ALPHA: return 2; + case LCT_RGBA: return 4; + case LCT_MAX_OCTET_VALUE: return 0; /* invalid color type */ + default: return 0; /*invalid color type*/ + } +} + +static unsigned lodepng_get_bpp_lct(LodePNGColorType colortype, unsigned bitdepth) { + /*bits per pixel is amount of channels * bits per channel*/ + return getNumColorChannels(colortype) * bitdepth; +} + +/* ////////////////////////////////////////////////////////////////////////// */ + +void lodepng_color_mode_init(LodePNGColorMode* info) { + info->key_defined = 0; + info->key_r = info->key_g = info->key_b = 0; + info->colortype = LCT_RGBA; + info->bitdepth = 8; + info->palette = 0; + info->palettesize = 0; +} + +/*allocates palette memory if needed, and initializes all colors to black*/ +static void lodepng_color_mode_alloc_palette(LodePNGColorMode* info) { + size_t i; + /*if the palette is already allocated, it will have size 1024 so no reallocation needed in that case*/ + /*the palette must have room for up to 256 colors with 4 bytes each.*/ + if(!info->palette) info->palette = (unsigned char*)lodepng_malloc(1024); + if(!info->palette) return; /*alloc fail*/ + for(i = 0; i != 256; ++i) { + /*Initialize all unused colors with black, the value used for invalid palette indices. + This is an error according to the PNG spec, but common PNG decoders make it black instead. + That makes color conversion slightly faster due to no error handling needed.*/ + info->palette[i * 4 + 0] = 0; + info->palette[i * 4 + 1] = 0; + info->palette[i * 4 + 2] = 0; + info->palette[i * 4 + 3] = 255; + } +} + +void lodepng_color_mode_cleanup(LodePNGColorMode* info) { + lodepng_palette_clear(info); +} + +unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source) { + lodepng_color_mode_cleanup(dest); + lodepng_memcpy(dest, source, sizeof(LodePNGColorMode)); + if(source->palette) { + dest->palette = (unsigned char*)lodepng_malloc(1024); + if(!dest->palette && source->palettesize) return 83; /*alloc fail*/ + lodepng_memcpy(dest->palette, source->palette, source->palettesize * 4); + } + return 0; +} + +LodePNGColorMode lodepng_color_mode_make(LodePNGColorType colortype, unsigned bitdepth) { + LodePNGColorMode result; + lodepng_color_mode_init(&result); + result.colortype = colortype; + result.bitdepth = bitdepth; + return result; +} + +static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b) { + size_t i; + if(a->colortype != b->colortype) return 0; + if(a->bitdepth != b->bitdepth) return 0; + if(a->key_defined != b->key_defined) return 0; + if(a->key_defined) { + if(a->key_r != b->key_r) return 0; + if(a->key_g != b->key_g) return 0; + if(a->key_b != b->key_b) return 0; + } + if(a->palettesize != b->palettesize) return 0; + for(i = 0; i != a->palettesize * 4; ++i) { + if(a->palette[i] != b->palette[i]) return 0; + } + return 1; +} + +void lodepng_palette_clear(LodePNGColorMode* info) { + if(info->palette) lodepng_free(info->palette); + info->palette = 0; + info->palettesize = 0; +} + +unsigned lodepng_palette_add(LodePNGColorMode* info, + unsigned char r, unsigned char g, unsigned char b, unsigned char a) { + if(!info->palette) /*allocate palette if empty*/ { + lodepng_color_mode_alloc_palette(info); + if(!info->palette) return 83; /*alloc fail*/ + } + if(info->palettesize >= 256) { + return 108; /*too many palette values*/ + } + info->palette[4 * info->palettesize + 0] = r; + info->palette[4 * info->palettesize + 1] = g; + info->palette[4 * info->palettesize + 2] = b; + info->palette[4 * info->palettesize + 3] = a; + ++info->palettesize; + return 0; +} + +/*calculate bits per pixel out of colortype and bitdepth*/ +unsigned lodepng_get_bpp(const LodePNGColorMode* info) { + return lodepng_get_bpp_lct(info->colortype, info->bitdepth); +} + +unsigned lodepng_get_channels(const LodePNGColorMode* info) { + return getNumColorChannels(info->colortype); +} + +unsigned lodepng_is_greyscale_type(const LodePNGColorMode* info) { + return info->colortype == LCT_GREY || info->colortype == LCT_GREY_ALPHA; +} + +unsigned lodepng_is_alpha_type(const LodePNGColorMode* info) { + return (info->colortype & 4) != 0; /*4 or 6*/ +} + +unsigned lodepng_is_palette_type(const LodePNGColorMode* info) { + return info->colortype == LCT_PALETTE; +} + +unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info) { + size_t i; + for(i = 0; i != info->palettesize; ++i) { + if(info->palette[i * 4 + 3] < 255) return 1; + } + return 0; +} + +unsigned lodepng_can_have_alpha(const LodePNGColorMode* info) { + return info->key_defined + || lodepng_is_alpha_type(info) + || lodepng_has_palette_alpha(info); +} + +static size_t lodepng_get_raw_size_lct(unsigned w, unsigned h, LodePNGColorType colortype, unsigned bitdepth) { + size_t bpp = lodepng_get_bpp_lct(colortype, bitdepth); + size_t n = (size_t)w * (size_t)h; + return ((n / 8u) * bpp) + ((n & 7u) * bpp + 7u) / 8u; +} + +size_t lodepng_get_raw_size(unsigned w, unsigned h, const LodePNGColorMode* color) { + return lodepng_get_raw_size_lct(w, h, color->colortype, color->bitdepth); +} + + +#ifdef LODEPNG_COMPILE_PNG + +/*in an idat chunk, each scanline is a multiple of 8 bits, unlike the lodepng output buffer, +and in addition has one extra byte per line: the filter byte. So this gives a larger +result than lodepng_get_raw_size. Set h to 1 to get the size of 1 row including filter byte. */ +static size_t lodepng_get_raw_size_idat(unsigned w, unsigned h, unsigned bpp) { + /* + 1 for the filter byte, and possibly plus padding bits per line. */ + /* Ignoring casts, the expression is equal to (w * bpp + 7) / 8 + 1, but avoids overflow of w * bpp */ + size_t line = ((size_t)(w / 8u) * bpp) + 1u + ((w & 7u) * bpp + 7u) / 8u; + return (size_t)h * line; +} + +#ifdef LODEPNG_COMPILE_DECODER +/*Safely checks whether size_t overflow can be caused due to amount of pixels. +This check is overcautious rather than precise. If this check indicates no overflow, +you can safely compute in a size_t (but not an unsigned): +-(size_t)w * (size_t)h * 8 +-amount of bytes in IDAT (including filter, padding and Adam7 bytes) +-amount of bytes in raw color model +Returns 1 if overflow possible, 0 if not. +*/ +static int lodepng_pixel_overflow(unsigned w, unsigned h, + const LodePNGColorMode* pngcolor, const LodePNGColorMode* rawcolor) { + size_t bpp = LODEPNG_MAX(lodepng_get_bpp(pngcolor), lodepng_get_bpp(rawcolor)); + size_t numpixels, total; + size_t line; /* bytes per line in worst case */ + + if(lodepng_mulofl((size_t)w, (size_t)h, &numpixels)) return 1; + if(lodepng_mulofl(numpixels, 8, &total)) return 1; /* bit pointer with 8-bit color, or 8 bytes per channel color */ + + /* Bytes per scanline with the expression "(w / 8u) * bpp) + ((w & 7u) * bpp + 7u) / 8u" */ + if(lodepng_mulofl((size_t)(w / 8u), bpp, &line)) return 1; + if(lodepng_addofl(line, ((w & 7u) * bpp + 7u) / 8u, &line)) return 1; + + if(lodepng_addofl(line, 5, &line)) return 1; /* 5 bytes overhead per line: 1 filterbyte, 4 for Adam7 worst case */ + if(lodepng_mulofl(line, h, &total)) return 1; /* Total bytes in worst case */ + + return 0; /* no overflow */ +} +#endif /*LODEPNG_COMPILE_DECODER*/ +#endif /*LODEPNG_COMPILE_PNG*/ + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + +static void LodePNGUnknownChunks_init(LodePNGInfo* info) { + unsigned i; + for(i = 0; i != 3; ++i) info->unknown_chunks_data[i] = 0; + for(i = 0; i != 3; ++i) info->unknown_chunks_size[i] = 0; +} + +static void LodePNGUnknownChunks_cleanup(LodePNGInfo* info) { + unsigned i; + for(i = 0; i != 3; ++i) lodepng_free(info->unknown_chunks_data[i]); +} + +static unsigned LodePNGUnknownChunks_copy(LodePNGInfo* dest, const LodePNGInfo* src) { + unsigned i; + + LodePNGUnknownChunks_cleanup(dest); + + for(i = 0; i != 3; ++i) { + size_t j; + dest->unknown_chunks_size[i] = src->unknown_chunks_size[i]; + dest->unknown_chunks_data[i] = (unsigned char*)lodepng_malloc(src->unknown_chunks_size[i]); + if(!dest->unknown_chunks_data[i] && dest->unknown_chunks_size[i]) return 83; /*alloc fail*/ + for(j = 0; j < src->unknown_chunks_size[i]; ++j) { + dest->unknown_chunks_data[i][j] = src->unknown_chunks_data[i][j]; + } + } + + return 0; +} + +/******************************************************************************/ + +static void LodePNGText_init(LodePNGInfo* info) { + info->text_num = 0; + info->text_keys = NULL; + info->text_strings = NULL; +} + +static void LodePNGText_cleanup(LodePNGInfo* info) { + size_t i; + for(i = 0; i != info->text_num; ++i) { + string_cleanup(&info->text_keys[i]); + string_cleanup(&info->text_strings[i]); + } + lodepng_free(info->text_keys); + lodepng_free(info->text_strings); +} + +static unsigned LodePNGText_copy(LodePNGInfo* dest, const LodePNGInfo* source) { + size_t i = 0; + dest->text_keys = NULL; + dest->text_strings = NULL; + dest->text_num = 0; + for(i = 0; i != source->text_num; ++i) { + CERROR_TRY_RETURN(lodepng_add_text(dest, source->text_keys[i], source->text_strings[i])); + } + return 0; +} + +static unsigned lodepng_add_text_sized(LodePNGInfo* info, const char* key, const char* str, size_t size) { + char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1))); + char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1))); + + if(new_keys) info->text_keys = new_keys; + if(new_strings) info->text_strings = new_strings; + + if(!new_keys || !new_strings) return 83; /*alloc fail*/ + + ++info->text_num; + info->text_keys[info->text_num - 1] = alloc_string(key); + info->text_strings[info->text_num - 1] = alloc_string_sized(str, size); + if(!info->text_keys[info->text_num - 1] || !info->text_strings[info->text_num - 1]) return 83; /*alloc fail*/ + + return 0; +} + +unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str) { + return lodepng_add_text_sized(info, key, str, lodepng_strlen(str)); +} + +void lodepng_clear_text(LodePNGInfo* info) { + LodePNGText_cleanup(info); +} + +/******************************************************************************/ + +static void LodePNGIText_init(LodePNGInfo* info) { + info->itext_num = 0; + info->itext_keys = NULL; + info->itext_langtags = NULL; + info->itext_transkeys = NULL; + info->itext_strings = NULL; +} + +static void LodePNGIText_cleanup(LodePNGInfo* info) { + size_t i; + for(i = 0; i != info->itext_num; ++i) { + string_cleanup(&info->itext_keys[i]); + string_cleanup(&info->itext_langtags[i]); + string_cleanup(&info->itext_transkeys[i]); + string_cleanup(&info->itext_strings[i]); + } + lodepng_free(info->itext_keys); + lodepng_free(info->itext_langtags); + lodepng_free(info->itext_transkeys); + lodepng_free(info->itext_strings); +} + +static unsigned LodePNGIText_copy(LodePNGInfo* dest, const LodePNGInfo* source) { + size_t i = 0; + dest->itext_keys = NULL; + dest->itext_langtags = NULL; + dest->itext_transkeys = NULL; + dest->itext_strings = NULL; + dest->itext_num = 0; + for(i = 0; i != source->itext_num; ++i) { + CERROR_TRY_RETURN(lodepng_add_itext(dest, source->itext_keys[i], source->itext_langtags[i], + source->itext_transkeys[i], source->itext_strings[i])); + } + return 0; +} + +void lodepng_clear_itext(LodePNGInfo* info) { + LodePNGIText_cleanup(info); +} + +static unsigned lodepng_add_itext_sized(LodePNGInfo* info, const char* key, const char* langtag, + const char* transkey, const char* str, size_t size) { + char** new_keys = (char**)(lodepng_realloc(info->itext_keys, sizeof(char*) * (info->itext_num + 1))); + char** new_langtags = (char**)(lodepng_realloc(info->itext_langtags, sizeof(char*) * (info->itext_num + 1))); + char** new_transkeys = (char**)(lodepng_realloc(info->itext_transkeys, sizeof(char*) * (info->itext_num + 1))); + char** new_strings = (char**)(lodepng_realloc(info->itext_strings, sizeof(char*) * (info->itext_num + 1))); + + if(new_keys) info->itext_keys = new_keys; + if(new_langtags) info->itext_langtags = new_langtags; + if(new_transkeys) info->itext_transkeys = new_transkeys; + if(new_strings) info->itext_strings = new_strings; + + if(!new_keys || !new_langtags || !new_transkeys || !new_strings) return 83; /*alloc fail*/ + + ++info->itext_num; + + info->itext_keys[info->itext_num - 1] = alloc_string(key); + info->itext_langtags[info->itext_num - 1] = alloc_string(langtag); + info->itext_transkeys[info->itext_num - 1] = alloc_string(transkey); + info->itext_strings[info->itext_num - 1] = alloc_string_sized(str, size); + + return 0; +} + +unsigned lodepng_add_itext(LodePNGInfo* info, const char* key, const char* langtag, + const char* transkey, const char* str) { + return lodepng_add_itext_sized(info, key, langtag, transkey, str, lodepng_strlen(str)); +} + +/* same as set but does not delete */ +static unsigned lodepng_assign_icc(LodePNGInfo* info, const char* name, const unsigned char* profile, unsigned profile_size) { + if(profile_size == 0) return 100; /*invalid ICC profile size*/ + + info->iccp_name = alloc_string(name); + info->iccp_profile = (unsigned char*)lodepng_malloc(profile_size); + + if(!info->iccp_name || !info->iccp_profile) return 83; /*alloc fail*/ + + lodepng_memcpy(info->iccp_profile, profile, profile_size); + info->iccp_profile_size = profile_size; + + return 0; /*ok*/ +} + +unsigned lodepng_set_icc(LodePNGInfo* info, const char* name, const unsigned char* profile, unsigned profile_size) { + if(info->iccp_name) lodepng_clear_icc(info); + info->iccp_defined = 1; + + return lodepng_assign_icc(info, name, profile, profile_size); +} + +void lodepng_clear_icc(LodePNGInfo* info) { + string_cleanup(&info->iccp_name); + lodepng_free(info->iccp_profile); + info->iccp_profile = NULL; + info->iccp_profile_size = 0; + info->iccp_defined = 0; +} +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + +void lodepng_info_init(LodePNGInfo* info) { + lodepng_color_mode_init(&info->color); + info->interlace_method = 0; + info->compression_method = 0; + info->filter_method = 0; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + info->background_defined = 0; + info->background_r = info->background_g = info->background_b = 0; + + LodePNGText_init(info); + LodePNGIText_init(info); + + info->time_defined = 0; + info->phys_defined = 0; + + info->gama_defined = 0; + info->chrm_defined = 0; + info->srgb_defined = 0; + info->iccp_defined = 0; + info->iccp_name = NULL; + info->iccp_profile = NULL; + + LodePNGUnknownChunks_init(info); +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ +} + +void lodepng_info_cleanup(LodePNGInfo* info) { + lodepng_color_mode_cleanup(&info->color); +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + LodePNGText_cleanup(info); + LodePNGIText_cleanup(info); + + lodepng_clear_icc(info); + + LodePNGUnknownChunks_cleanup(info); +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ +} + +unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source) { + lodepng_info_cleanup(dest); + lodepng_memcpy(dest, source, sizeof(LodePNGInfo)); + lodepng_color_mode_init(&dest->color); + CERROR_TRY_RETURN(lodepng_color_mode_copy(&dest->color, &source->color)); + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + CERROR_TRY_RETURN(LodePNGText_copy(dest, source)); + CERROR_TRY_RETURN(LodePNGIText_copy(dest, source)); + if(source->iccp_defined) { + CERROR_TRY_RETURN(lodepng_assign_icc(dest, source->iccp_name, source->iccp_profile, source->iccp_profile_size)); + } + + LodePNGUnknownChunks_init(dest); + CERROR_TRY_RETURN(LodePNGUnknownChunks_copy(dest, source)); +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + return 0; +} + +/* ////////////////////////////////////////////////////////////////////////// */ + +/*index: bitgroup index, bits: bitgroup size(1, 2 or 4), in: bitgroup value, out: octet array to add bits to*/ +static void addColorBits(unsigned char* out, size_t index, unsigned bits, unsigned in) { + unsigned m = bits == 1 ? 7 : bits == 2 ? 3 : 1; /*8 / bits - 1*/ + /*p = the partial index in the byte, e.g. with 4 palettebits it is 0 for first half or 1 for second half*/ + unsigned p = index & m; + in &= (1u << bits) - 1u; /*filter out any other bits of the input value*/ + in = in << (bits * (m - p)); + if(p == 0) out[index * bits / 8u] = in; + else out[index * bits / 8u] |= in; +} + +typedef struct ColorTree ColorTree; + +/* +One node of a color tree +This is the data structure used to count the number of unique colors and to get a palette +index for a color. It's like an octree, but because the alpha channel is used too, each +node has 16 instead of 8 children. +*/ +struct ColorTree { + ColorTree* children[16]; /*up to 16 pointers to ColorTree of next level*/ + int index; /*the payload. Only has a meaningful value if this is in the last level*/ +}; + +static void color_tree_init(ColorTree* tree) { + lodepng_memset(tree->children, 0, 16 * sizeof(*tree->children)); + tree->index = -1; +} + +static void color_tree_cleanup(ColorTree* tree) { + int i; + for(i = 0; i != 16; ++i) { + if(tree->children[i]) { + color_tree_cleanup(tree->children[i]); + lodepng_free(tree->children[i]); + } + } +} + +/*returns -1 if color not present, its index otherwise*/ +static int color_tree_get(ColorTree* tree, unsigned char r, unsigned char g, unsigned char b, unsigned char a) { + int bit = 0; + for(bit = 0; bit < 8; ++bit) { + int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1); + if(!tree->children[i]) return -1; + else tree = tree->children[i]; + } + return tree ? tree->index : -1; +} + +#ifdef LODEPNG_COMPILE_ENCODER +static int color_tree_has(ColorTree* tree, unsigned char r, unsigned char g, unsigned char b, unsigned char a) { + return color_tree_get(tree, r, g, b, a) >= 0; +} +#endif /*LODEPNG_COMPILE_ENCODER*/ + +/*color is not allowed to already exist. +Index should be >= 0 (it's signed to be compatible with using -1 for "doesn't exist") +Returns error code, or 0 if ok*/ +static unsigned color_tree_add(ColorTree* tree, + unsigned char r, unsigned char g, unsigned char b, unsigned char a, unsigned index) { + int bit; + for(bit = 0; bit < 8; ++bit) { + int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1); + if(!tree->children[i]) { + tree->children[i] = (ColorTree*)lodepng_malloc(sizeof(ColorTree)); + if(!tree->children[i]) return 83; /*alloc fail*/ + color_tree_init(tree->children[i]); + } + tree = tree->children[i]; + } + tree->index = (int)index; + return 0; +} + +/*put a pixel, given its RGBA color, into image of any color type*/ +static unsigned rgba8ToPixel(unsigned char* out, size_t i, + const LodePNGColorMode* mode, ColorTree* tree /*for palette*/, + unsigned char r, unsigned char g, unsigned char b, unsigned char a) { + if(mode->colortype == LCT_GREY) { + unsigned char gray = r; /*((unsigned short)r + g + b) / 3u;*/ + if(mode->bitdepth == 8) out[i] = gray; + else if(mode->bitdepth == 16) out[i * 2 + 0] = out[i * 2 + 1] = gray; + else { + /*take the most significant bits of gray*/ + gray = ((unsigned)gray >> (8u - mode->bitdepth)) & ((1u << mode->bitdepth) - 1u); + addColorBits(out, i, mode->bitdepth, gray); + } + } else if(mode->colortype == LCT_RGB) { + if(mode->bitdepth == 8) { + out[i * 3 + 0] = r; + out[i * 3 + 1] = g; + out[i * 3 + 2] = b; + } else { + out[i * 6 + 0] = out[i * 6 + 1] = r; + out[i * 6 + 2] = out[i * 6 + 3] = g; + out[i * 6 + 4] = out[i * 6 + 5] = b; + } + } else if(mode->colortype == LCT_PALETTE) { + int index = color_tree_get(tree, r, g, b, a); + if(index < 0) return 82; /*color not in palette*/ + if(mode->bitdepth == 8) out[i] = index; + else addColorBits(out, i, mode->bitdepth, (unsigned)index); + } else if(mode->colortype == LCT_GREY_ALPHA) { + unsigned char gray = r; /*((unsigned short)r + g + b) / 3u;*/ + if(mode->bitdepth == 8) { + out[i * 2 + 0] = gray; + out[i * 2 + 1] = a; + } else if(mode->bitdepth == 16) { + out[i * 4 + 0] = out[i * 4 + 1] = gray; + out[i * 4 + 2] = out[i * 4 + 3] = a; + } + } else if(mode->colortype == LCT_RGBA) { + if(mode->bitdepth == 8) { + out[i * 4 + 0] = r; + out[i * 4 + 1] = g; + out[i * 4 + 2] = b; + out[i * 4 + 3] = a; + } else { + out[i * 8 + 0] = out[i * 8 + 1] = r; + out[i * 8 + 2] = out[i * 8 + 3] = g; + out[i * 8 + 4] = out[i * 8 + 5] = b; + out[i * 8 + 6] = out[i * 8 + 7] = a; + } + } + + return 0; /*no error*/ +} + +/*put a pixel, given its RGBA16 color, into image of any color 16-bitdepth type*/ +static void rgba16ToPixel(unsigned char* out, size_t i, + const LodePNGColorMode* mode, + unsigned short r, unsigned short g, unsigned short b, unsigned short a) { + if(mode->colortype == LCT_GREY) { + unsigned short gray = r; /*((unsigned)r + g + b) / 3u;*/ + out[i * 2 + 0] = (gray >> 8) & 255; + out[i * 2 + 1] = gray & 255; + } else if(mode->colortype == LCT_RGB) { + out[i * 6 + 0] = (r >> 8) & 255; + out[i * 6 + 1] = r & 255; + out[i * 6 + 2] = (g >> 8) & 255; + out[i * 6 + 3] = g & 255; + out[i * 6 + 4] = (b >> 8) & 255; + out[i * 6 + 5] = b & 255; + } else if(mode->colortype == LCT_GREY_ALPHA) { + unsigned short gray = r; /*((unsigned)r + g + b) / 3u;*/ + out[i * 4 + 0] = (gray >> 8) & 255; + out[i * 4 + 1] = gray & 255; + out[i * 4 + 2] = (a >> 8) & 255; + out[i * 4 + 3] = a & 255; + } else if(mode->colortype == LCT_RGBA) { + out[i * 8 + 0] = (r >> 8) & 255; + out[i * 8 + 1] = r & 255; + out[i * 8 + 2] = (g >> 8) & 255; + out[i * 8 + 3] = g & 255; + out[i * 8 + 4] = (b >> 8) & 255; + out[i * 8 + 5] = b & 255; + out[i * 8 + 6] = (a >> 8) & 255; + out[i * 8 + 7] = a & 255; + } +} + +/*Get RGBA8 color of pixel with index i (y * width + x) from the raw image with given color type.*/ +static void getPixelColorRGBA8(unsigned char* r, unsigned char* g, + unsigned char* b, unsigned char* a, + const unsigned char* in, size_t i, + const LodePNGColorMode* mode) { + if(mode->colortype == LCT_GREY) { + if(mode->bitdepth == 8) { + *r = *g = *b = in[i]; + if(mode->key_defined && *r == mode->key_r) *a = 0; + else *a = 255; + } else if(mode->bitdepth == 16) { + *r = *g = *b = in[i * 2 + 0]; + if(mode->key_defined && 256U * in[i * 2 + 0] + in[i * 2 + 1] == mode->key_r) *a = 0; + else *a = 255; + } else { + unsigned highest = ((1U << mode->bitdepth) - 1U); /*highest possible value for this bit depth*/ + size_t j = i * mode->bitdepth; + unsigned value = readBitsFromReversedStream(&j, in, mode->bitdepth); + *r = *g = *b = (value * 255) / highest; + if(mode->key_defined && value == mode->key_r) *a = 0; + else *a = 255; + } + } else if(mode->colortype == LCT_RGB) { + if(mode->bitdepth == 8) { + *r = in[i * 3 + 0]; *g = in[i * 3 + 1]; *b = in[i * 3 + 2]; + if(mode->key_defined && *r == mode->key_r && *g == mode->key_g && *b == mode->key_b) *a = 0; + else *a = 255; + } else { + *r = in[i * 6 + 0]; + *g = in[i * 6 + 2]; + *b = in[i * 6 + 4]; + if(mode->key_defined && 256U * in[i * 6 + 0] + in[i * 6 + 1] == mode->key_r + && 256U * in[i * 6 + 2] + in[i * 6 + 3] == mode->key_g + && 256U * in[i * 6 + 4] + in[i * 6 + 5] == mode->key_b) *a = 0; + else *a = 255; + } + } else if(mode->colortype == LCT_PALETTE) { + unsigned index; + if(mode->bitdepth == 8) index = in[i]; + else { + size_t j = i * mode->bitdepth; + index = readBitsFromReversedStream(&j, in, mode->bitdepth); + } + /*out of bounds of palette not checked: see lodepng_color_mode_alloc_palette.*/ + *r = mode->palette[index * 4 + 0]; + *g = mode->palette[index * 4 + 1]; + *b = mode->palette[index * 4 + 2]; + *a = mode->palette[index * 4 + 3]; + } else if(mode->colortype == LCT_GREY_ALPHA) { + if(mode->bitdepth == 8) { + *r = *g = *b = in[i * 2 + 0]; + *a = in[i * 2 + 1]; + } else { + *r = *g = *b = in[i * 4 + 0]; + *a = in[i * 4 + 2]; + } + } else if(mode->colortype == LCT_RGBA) { + if(mode->bitdepth == 8) { + *r = in[i * 4 + 0]; + *g = in[i * 4 + 1]; + *b = in[i * 4 + 2]; + *a = in[i * 4 + 3]; + } else { + *r = in[i * 8 + 0]; + *g = in[i * 8 + 2]; + *b = in[i * 8 + 4]; + *a = in[i * 8 + 6]; + } + } +} + +/*Similar to getPixelColorRGBA8, but with all the for loops inside of the color +mode test cases, optimized to convert the colors much faster, when converting +to the common case of RGBA with 8 bit per channel. buffer must be RGBA with +enough memory.*/ +static void getPixelColorsRGBA8(unsigned char* LODEPNG_RESTRICT buffer, size_t numpixels, + const unsigned char* LODEPNG_RESTRICT in, + const LodePNGColorMode* mode) { + unsigned num_channels = 4; + size_t i; + if(mode->colortype == LCT_GREY) { + if(mode->bitdepth == 8) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = buffer[1] = buffer[2] = in[i]; + buffer[3] = 255; + } + if(mode->key_defined) { + buffer -= numpixels * num_channels; + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + if(buffer[0] == mode->key_r) buffer[3] = 0; + } + } + } else if(mode->bitdepth == 16) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = buffer[1] = buffer[2] = in[i * 2]; + buffer[3] = mode->key_defined && 256U * in[i * 2 + 0] + in[i * 2 + 1] == mode->key_r ? 0 : 255; + } + } else { + unsigned highest = ((1U << mode->bitdepth) - 1U); /*highest possible value for this bit depth*/ + size_t j = 0; + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + unsigned value = readBitsFromReversedStream(&j, in, mode->bitdepth); + buffer[0] = buffer[1] = buffer[2] = (value * 255) / highest; + buffer[3] = mode->key_defined && value == mode->key_r ? 0 : 255; + } + } + } else if(mode->colortype == LCT_RGB) { + if(mode->bitdepth == 8) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + lodepng_memcpy(buffer, &in[i * 3], 3); + buffer[3] = 255; + } + if(mode->key_defined) { + buffer -= numpixels * num_channels; + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + if(buffer[0] == mode->key_r && buffer[1]== mode->key_g && buffer[2] == mode->key_b) buffer[3] = 0; + } + } + } else { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = in[i * 6 + 0]; + buffer[1] = in[i * 6 + 2]; + buffer[2] = in[i * 6 + 4]; + buffer[3] = mode->key_defined + && 256U * in[i * 6 + 0] + in[i * 6 + 1] == mode->key_r + && 256U * in[i * 6 + 2] + in[i * 6 + 3] == mode->key_g + && 256U * in[i * 6 + 4] + in[i * 6 + 5] == mode->key_b ? 0 : 255; + } + } + } else if(mode->colortype == LCT_PALETTE) { + if(mode->bitdepth == 8) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + unsigned index = in[i]; + /*out of bounds of palette not checked: see lodepng_color_mode_alloc_palette.*/ + lodepng_memcpy(buffer, &mode->palette[index * 4], 4); + } + } else { + size_t j = 0; + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + unsigned index = readBitsFromReversedStream(&j, in, mode->bitdepth); + /*out of bounds of palette not checked: see lodepng_color_mode_alloc_palette.*/ + lodepng_memcpy(buffer, &mode->palette[index * 4], 4); + } + } + } else if(mode->colortype == LCT_GREY_ALPHA) { + if(mode->bitdepth == 8) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = buffer[1] = buffer[2] = in[i * 2 + 0]; + buffer[3] = in[i * 2 + 1]; + } + } else { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = buffer[1] = buffer[2] = in[i * 4 + 0]; + buffer[3] = in[i * 4 + 2]; + } + } + } else if(mode->colortype == LCT_RGBA) { + if(mode->bitdepth == 8) { + lodepng_memcpy(buffer, in, numpixels * 4); + } else { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = in[i * 8 + 0]; + buffer[1] = in[i * 8 + 2]; + buffer[2] = in[i * 8 + 4]; + buffer[3] = in[i * 8 + 6]; + } + } + } +} + +/*Similar to getPixelColorsRGBA8, but with 3-channel RGB output.*/ +static void getPixelColorsRGB8(unsigned char* LODEPNG_RESTRICT buffer, size_t numpixels, + const unsigned char* LODEPNG_RESTRICT in, + const LodePNGColorMode* mode) { + const unsigned num_channels = 3; + size_t i; + if(mode->colortype == LCT_GREY) { + if(mode->bitdepth == 8) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = buffer[1] = buffer[2] = in[i]; + } + } else if(mode->bitdepth == 16) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = buffer[1] = buffer[2] = in[i * 2]; + } + } else { + unsigned highest = ((1U << mode->bitdepth) - 1U); /*highest possible value for this bit depth*/ + size_t j = 0; + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + unsigned value = readBitsFromReversedStream(&j, in, mode->bitdepth); + buffer[0] = buffer[1] = buffer[2] = (value * 255) / highest; + } + } + } else if(mode->colortype == LCT_RGB) { + if(mode->bitdepth == 8) { + lodepng_memcpy(buffer, in, numpixels * 3); + } else { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = in[i * 6 + 0]; + buffer[1] = in[i * 6 + 2]; + buffer[2] = in[i * 6 + 4]; + } + } + } else if(mode->colortype == LCT_PALETTE) { + if(mode->bitdepth == 8) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + unsigned index = in[i]; + /*out of bounds of palette not checked: see lodepng_color_mode_alloc_palette.*/ + lodepng_memcpy(buffer, &mode->palette[index * 4], 3); + } + } else { + size_t j = 0; + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + unsigned index = readBitsFromReversedStream(&j, in, mode->bitdepth); + /*out of bounds of palette not checked: see lodepng_color_mode_alloc_palette.*/ + lodepng_memcpy(buffer, &mode->palette[index * 4], 3); + } + } + } else if(mode->colortype == LCT_GREY_ALPHA) { + if(mode->bitdepth == 8) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = buffer[1] = buffer[2] = in[i * 2 + 0]; + } + } else { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = buffer[1] = buffer[2] = in[i * 4 + 0]; + } + } + } else if(mode->colortype == LCT_RGBA) { + if(mode->bitdepth == 8) { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + lodepng_memcpy(buffer, &in[i * 4], 3); + } + } else { + for(i = 0; i != numpixels; ++i, buffer += num_channels) { + buffer[0] = in[i * 8 + 0]; + buffer[1] = in[i * 8 + 2]; + buffer[2] = in[i * 8 + 4]; + } + } + } +} + +/*Get RGBA16 color of pixel with index i (y * width + x) from the raw image with +given color type, but the given color type must be 16-bit itself.*/ +static void getPixelColorRGBA16(unsigned short* r, unsigned short* g, unsigned short* b, unsigned short* a, + const unsigned char* in, size_t i, const LodePNGColorMode* mode) { + if(mode->colortype == LCT_GREY) { + *r = *g = *b = 256 * in[i * 2 + 0] + in[i * 2 + 1]; + if(mode->key_defined && 256U * in[i * 2 + 0] + in[i * 2 + 1] == mode->key_r) *a = 0; + else *a = 65535; + } else if(mode->colortype == LCT_RGB) { + *r = 256u * in[i * 6 + 0] + in[i * 6 + 1]; + *g = 256u * in[i * 6 + 2] + in[i * 6 + 3]; + *b = 256u * in[i * 6 + 4] + in[i * 6 + 5]; + if(mode->key_defined + && 256u * in[i * 6 + 0] + in[i * 6 + 1] == mode->key_r + && 256u * in[i * 6 + 2] + in[i * 6 + 3] == mode->key_g + && 256u * in[i * 6 + 4] + in[i * 6 + 5] == mode->key_b) *a = 0; + else *a = 65535; + } else if(mode->colortype == LCT_GREY_ALPHA) { + *r = *g = *b = 256u * in[i * 4 + 0] + in[i * 4 + 1]; + *a = 256u * in[i * 4 + 2] + in[i * 4 + 3]; + } else if(mode->colortype == LCT_RGBA) { + *r = 256u * in[i * 8 + 0] + in[i * 8 + 1]; + *g = 256u * in[i * 8 + 2] + in[i * 8 + 3]; + *b = 256u * in[i * 8 + 4] + in[i * 8 + 5]; + *a = 256u * in[i * 8 + 6] + in[i * 8 + 7]; + } +} + +unsigned lodepng_convert(unsigned char* out, const unsigned char* in, + const LodePNGColorMode* mode_out, const LodePNGColorMode* mode_in, + unsigned w, unsigned h) { + size_t i; + ColorTree tree; + size_t numpixels = (size_t)w * (size_t)h; + unsigned error = 0; + + if(mode_in->colortype == LCT_PALETTE && !mode_in->palette) { + return 107; /* error: must provide palette if input mode is palette */ + } + + if(lodepng_color_mode_equal(mode_out, mode_in)) { + size_t numbytes = lodepng_get_raw_size(w, h, mode_in); + lodepng_memcpy(out, in, numbytes); + return 0; + } + + if(mode_out->colortype == LCT_PALETTE) { + size_t palettesize = mode_out->palettesize; + const unsigned char* palette = mode_out->palette; + size_t palsize = (size_t)1u << mode_out->bitdepth; + /*if the user specified output palette but did not give the values, assume + they want the values of the input color type (assuming that one is palette). + Note that we never create a new palette ourselves.*/ + if(palettesize == 0) { + palettesize = mode_in->palettesize; + palette = mode_in->palette; + /*if the input was also palette with same bitdepth, then the color types are also + equal, so copy literally. This to preserve the exact indices that were in the PNG + even in case there are duplicate colors in the palette.*/ + if(mode_in->colortype == LCT_PALETTE && mode_in->bitdepth == mode_out->bitdepth) { + size_t numbytes = lodepng_get_raw_size(w, h, mode_in); + lodepng_memcpy(out, in, numbytes); + return 0; + } + } + if(palettesize < palsize) palsize = palettesize; + color_tree_init(&tree); + for(i = 0; i != palsize; ++i) { + const unsigned char* p = &palette[i * 4]; + error = color_tree_add(&tree, p[0], p[1], p[2], p[3], (unsigned)i); + if(error) break; + } + } + + if(!error) { + if(mode_in->bitdepth == 16 && mode_out->bitdepth == 16) { + for(i = 0; i != numpixels; ++i) { + unsigned short r = 0, g = 0, b = 0, a = 0; + getPixelColorRGBA16(&r, &g, &b, &a, in, i, mode_in); + rgba16ToPixel(out, i, mode_out, r, g, b, a); + } + } else if(mode_out->bitdepth == 8 && mode_out->colortype == LCT_RGBA) { + getPixelColorsRGBA8(out, numpixels, in, mode_in); + } else if(mode_out->bitdepth == 8 && mode_out->colortype == LCT_RGB) { + getPixelColorsRGB8(out, numpixels, in, mode_in); + } else { + unsigned char r = 0, g = 0, b = 0, a = 0; + for(i = 0; i != numpixels; ++i) { + getPixelColorRGBA8(&r, &g, &b, &a, in, i, mode_in); + error = rgba8ToPixel(out, i, mode_out, &tree, r, g, b, a); + if(error) break; + } + } + } + + if(mode_out->colortype == LCT_PALETTE) { + color_tree_cleanup(&tree); + } + + return error; +} + + +/* Converts a single rgb color without alpha from one type to another, color bits truncated to +their bitdepth. In case of single channel (gray or palette), only the r channel is used. Slow +function, do not use to process all pixels of an image. Alpha channel not supported on purpose: +this is for bKGD, supporting alpha may prevent it from finding a color in the palette, from the +specification it looks like bKGD should ignore the alpha values of the palette since it can use +any palette index but doesn't have an alpha channel. Idem with ignoring color key. */ +unsigned lodepng_convert_rgb( + unsigned* r_out, unsigned* g_out, unsigned* b_out, + unsigned r_in, unsigned g_in, unsigned b_in, + const LodePNGColorMode* mode_out, const LodePNGColorMode* mode_in) { + unsigned r = 0, g = 0, b = 0; + unsigned mul = 65535 / ((1u << mode_in->bitdepth) - 1u); /*65535, 21845, 4369, 257, 1*/ + unsigned shift = 16 - mode_out->bitdepth; + + if(mode_in->colortype == LCT_GREY || mode_in->colortype == LCT_GREY_ALPHA) { + r = g = b = r_in * mul; + } else if(mode_in->colortype == LCT_RGB || mode_in->colortype == LCT_RGBA) { + r = r_in * mul; + g = g_in * mul; + b = b_in * mul; + } else if(mode_in->colortype == LCT_PALETTE) { + if(r_in >= mode_in->palettesize) return 82; + r = mode_in->palette[r_in * 4 + 0] * 257u; + g = mode_in->palette[r_in * 4 + 1] * 257u; + b = mode_in->palette[r_in * 4 + 2] * 257u; + } else { + return 31; + } + + /* now convert to output format */ + if(mode_out->colortype == LCT_GREY || mode_out->colortype == LCT_GREY_ALPHA) { + *r_out = r >> shift ; + } else if(mode_out->colortype == LCT_RGB || mode_out->colortype == LCT_RGBA) { + *r_out = r >> shift ; + *g_out = g >> shift ; + *b_out = b >> shift ; + } else if(mode_out->colortype == LCT_PALETTE) { + unsigned i; + /* a 16-bit color cannot be in the palette */ + if((r >> 8) != (r & 255) || (g >> 8) != (g & 255) || (b >> 8) != (b & 255)) return 82; + for(i = 0; i < mode_out->palettesize; i++) { + unsigned j = i * 4; + if((r >> 8) == mode_out->palette[j + 0] && (g >> 8) == mode_out->palette[j + 1] && + (b >> 8) == mode_out->palette[j + 2]) { + *r_out = i; + return 0; + } + } + return 82; + } else { + return 31; + } + + return 0; +} + +#ifdef LODEPNG_COMPILE_ENCODER + +void lodepng_color_stats_init(LodePNGColorStats* stats) { + /*stats*/ + stats->colored = 0; + stats->key = 0; + stats->key_r = stats->key_g = stats->key_b = 0; + stats->alpha = 0; + stats->numcolors = 0; + stats->bits = 1; + stats->numpixels = 0; + /*settings*/ + stats->allow_palette = 1; + stats->allow_greyscale = 1; +} + +/*function used for debug purposes with C++*/ +/*void printColorStats(LodePNGColorStats* p) { + std::cout << "colored: " << (int)p->colored << ", "; + std::cout << "key: " << (int)p->key << ", "; + std::cout << "key_r: " << (int)p->key_r << ", "; + std::cout << "key_g: " << (int)p->key_g << ", "; + std::cout << "key_b: " << (int)p->key_b << ", "; + std::cout << "alpha: " << (int)p->alpha << ", "; + std::cout << "numcolors: " << (int)p->numcolors << ", "; + std::cout << "bits: " << (int)p->bits << std::endl; +}*/ + +/*Returns how many bits needed to represent given value (max 8 bit)*/ +static unsigned getValueRequiredBits(unsigned char value) { + if(value == 0 || value == 255) return 1; + /*The scaling of 2-bit and 4-bit values uses multiples of 85 and 17*/ + if(value % 17 == 0) return value % 85 == 0 ? 2 : 4; + return 8; +} + +/*stats must already have been inited. */ +unsigned lodepng_compute_color_stats(LodePNGColorStats* stats, + const unsigned char* in, unsigned w, unsigned h, + const LodePNGColorMode* mode_in) { + size_t i; + ColorTree tree; + size_t numpixels = (size_t)w * (size_t)h; + unsigned error = 0; + + /* mark things as done already if it would be impossible to have a more expensive case */ + unsigned colored_done = lodepng_is_greyscale_type(mode_in) ? 1 : 0; + unsigned alpha_done = lodepng_can_have_alpha(mode_in) ? 0 : 1; + unsigned numcolors_done = 0; + unsigned bpp = lodepng_get_bpp(mode_in); + unsigned bits_done = (stats->bits == 1 && bpp == 1) ? 1 : 0; + unsigned sixteen = 0; /* whether the input image is 16 bit */ + unsigned maxnumcolors = 257; + if(bpp <= 8) maxnumcolors = LODEPNG_MIN(257, stats->numcolors + (1u << bpp)); + + stats->numpixels += numpixels; + + /*if palette not allowed, no need to compute numcolors*/ + if(!stats->allow_palette) numcolors_done = 1; + + color_tree_init(&tree); + + /*If the stats was already filled in from previous data, fill its palette in tree + and mark things as done already if we know they are the most expensive case already*/ + if(stats->alpha) alpha_done = 1; + if(stats->colored) colored_done = 1; + if(stats->bits == 16) numcolors_done = 1; + if(stats->bits >= bpp) bits_done = 1; + if(stats->numcolors >= maxnumcolors) numcolors_done = 1; + + if(!numcolors_done) { + for(i = 0; i < stats->numcolors; i++) { + const unsigned char* color = &stats->palette[i * 4]; + error = color_tree_add(&tree, color[0], color[1], color[2], color[3], i); + if(error) goto cleanup; + } + } + + /*Check if the 16-bit input is truly 16-bit*/ + if(mode_in->bitdepth == 16 && !sixteen) { + unsigned short r = 0, g = 0, b = 0, a = 0; + for(i = 0; i != numpixels; ++i) { + getPixelColorRGBA16(&r, &g, &b, &a, in, i, mode_in); + if((r & 255) != ((r >> 8) & 255) || (g & 255) != ((g >> 8) & 255) || + (b & 255) != ((b >> 8) & 255) || (a & 255) != ((a >> 8) & 255)) /*first and second byte differ*/ { + stats->bits = 16; + sixteen = 1; + bits_done = 1; + numcolors_done = 1; /*counting colors no longer useful, palette doesn't support 16-bit*/ + break; + } + } + } + + if(sixteen) { + unsigned short r = 0, g = 0, b = 0, a = 0; + + for(i = 0; i != numpixels; ++i) { + getPixelColorRGBA16(&r, &g, &b, &a, in, i, mode_in); + + if(!colored_done && (r != g || r != b)) { + stats->colored = 1; + colored_done = 1; + } + + if(!alpha_done) { + unsigned matchkey = (r == stats->key_r && g == stats->key_g && b == stats->key_b); + if(a != 65535 && (a != 0 || (stats->key && !matchkey))) { + stats->alpha = 1; + stats->key = 0; + alpha_done = 1; + } else if(a == 0 && !stats->alpha && !stats->key) { + stats->key = 1; + stats->key_r = r; + stats->key_g = g; + stats->key_b = b; + } else if(a == 65535 && stats->key && matchkey) { + /* Color key cannot be used if an opaque pixel also has that RGB color. */ + stats->alpha = 1; + stats->key = 0; + alpha_done = 1; + } + } + if(alpha_done && numcolors_done && colored_done && bits_done) break; + } + + if(stats->key && !stats->alpha) { + for(i = 0; i != numpixels; ++i) { + getPixelColorRGBA16(&r, &g, &b, &a, in, i, mode_in); + if(a != 0 && r == stats->key_r && g == stats->key_g && b == stats->key_b) { + /* Color key cannot be used if an opaque pixel also has that RGB color. */ + stats->alpha = 1; + stats->key = 0; + alpha_done = 1; + } + } + } + } else /* < 16-bit */ { + unsigned char r = 0, g = 0, b = 0, a = 0; + for(i = 0; i != numpixels; ++i) { + getPixelColorRGBA8(&r, &g, &b, &a, in, i, mode_in); + + if(!bits_done && stats->bits < 8) { + /*only r is checked, < 8 bits is only relevant for grayscale*/ + unsigned bits = getValueRequiredBits(r); + if(bits > stats->bits) stats->bits = bits; + } + bits_done = (stats->bits >= bpp); + + if(!colored_done && (r != g || r != b)) { + stats->colored = 1; + colored_done = 1; + if(stats->bits < 8) stats->bits = 8; /*PNG has no colored modes with less than 8-bit per channel*/ + } + + if(!alpha_done) { + unsigned matchkey = (r == stats->key_r && g == stats->key_g && b == stats->key_b); + if(a != 255 && (a != 0 || (stats->key && !matchkey))) { + stats->alpha = 1; + stats->key = 0; + alpha_done = 1; + if(stats->bits < 8) stats->bits = 8; /*PNG has no alphachannel modes with less than 8-bit per channel*/ + } else if(a == 0 && !stats->alpha && !stats->key) { + stats->key = 1; + stats->key_r = r; + stats->key_g = g; + stats->key_b = b; + } else if(a == 255 && stats->key && matchkey) { + /* Color key cannot be used if an opaque pixel also has that RGB color. */ + stats->alpha = 1; + stats->key = 0; + alpha_done = 1; + if(stats->bits < 8) stats->bits = 8; /*PNG has no alphachannel modes with less than 8-bit per channel*/ + } + } + + if(!numcolors_done) { + if(!color_tree_has(&tree, r, g, b, a)) { + error = color_tree_add(&tree, r, g, b, a, stats->numcolors); + if(error) goto cleanup; + if(stats->numcolors < 256) { + unsigned char* p = stats->palette; + unsigned n = stats->numcolors; + p[n * 4 + 0] = r; + p[n * 4 + 1] = g; + p[n * 4 + 2] = b; + p[n * 4 + 3] = a; + } + ++stats->numcolors; + numcolors_done = stats->numcolors >= maxnumcolors; + } + } + + if(alpha_done && numcolors_done && colored_done && bits_done) break; + } + + if(stats->key && !stats->alpha) { + for(i = 0; i != numpixels; ++i) { + getPixelColorRGBA8(&r, &g, &b, &a, in, i, mode_in); + if(a != 0 && r == stats->key_r && g == stats->key_g && b == stats->key_b) { + /* Color key cannot be used if an opaque pixel also has that RGB color. */ + stats->alpha = 1; + stats->key = 0; + alpha_done = 1; + if(stats->bits < 8) stats->bits = 8; /*PNG has no alphachannel modes with less than 8-bit per channel*/ + } + } + } + + /*make the stats's key always 16-bit for consistency - repeat each byte twice*/ + stats->key_r += (stats->key_r << 8); + stats->key_g += (stats->key_g << 8); + stats->key_b += (stats->key_b << 8); + } + +cleanup: + color_tree_cleanup(&tree); + return error; +} + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS +/*Adds a single color to the color stats. The stats must already have been inited. The color must be given as 16-bit +(with 2 bytes repeating for 8-bit and 65535 for opaque alpha channel). This function is expensive, do not call it for +all pixels of an image but only for a few additional values. */ +static unsigned lodepng_color_stats_add(LodePNGColorStats* stats, + unsigned r, unsigned g, unsigned b, unsigned a) { + unsigned error = 0; + unsigned char image[8]; + LodePNGColorMode mode; + lodepng_color_mode_init(&mode); + image[0] = r >> 8; image[1] = r; image[2] = g >> 8; image[3] = g; + image[4] = b >> 8; image[5] = b; image[6] = a >> 8; image[7] = a; + mode.bitdepth = 16; + mode.colortype = LCT_RGBA; + error = lodepng_compute_color_stats(stats, image, 1, 1, &mode); + lodepng_color_mode_cleanup(&mode); + return error; +} +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + +/*Computes a minimal PNG color model that can contain all colors as indicated by the stats. +The stats should be computed with lodepng_compute_color_stats. +mode_in is raw color profile of the image the stats were computed on, to copy palette order from when relevant. +Minimal PNG color model means the color type and bit depth that gives smallest amount of bits in the output image, +e.g. gray if only grayscale pixels, palette if less than 256 colors, color key if only single transparent color, ... +This is used if auto_convert is enabled (it is by default). +*/ +static unsigned auto_choose_color(LodePNGColorMode* mode_out, + const LodePNGColorMode* mode_in, + const LodePNGColorStats* stats) { + unsigned error = 0; + unsigned palettebits; + size_t i, n; + size_t numpixels = stats->numpixels; + unsigned palette_ok, gray_ok; + + unsigned alpha = stats->alpha; + unsigned key = stats->key; + unsigned bits = stats->bits; + + mode_out->key_defined = 0; + + if(key && numpixels <= 16) { + alpha = 1; /*too few pixels to justify tRNS chunk overhead*/ + key = 0; + if(bits < 8) bits = 8; /*PNG has no alphachannel modes with less than 8-bit per channel*/ + } + + gray_ok = !stats->colored; + if(!stats->allow_greyscale) gray_ok = 0; + if(!gray_ok && bits < 8) bits = 8; + + n = stats->numcolors; + palettebits = n <= 2 ? 1 : (n <= 4 ? 2 : (n <= 16 ? 4 : 8)); + palette_ok = n <= 256 && bits <= 8 && n != 0; /*n==0 means likely numcolors wasn't computed*/ + if(numpixels < n * 2) palette_ok = 0; /*don't add palette overhead if image has only a few pixels*/ + if(gray_ok && !alpha && bits <= palettebits) palette_ok = 0; /*gray is less overhead*/ + if(!stats->allow_palette) palette_ok = 0; + + if(palette_ok) { + const unsigned char* p = stats->palette; + lodepng_palette_clear(mode_out); /*remove potential earlier palette*/ + for(i = 0; i != stats->numcolors; ++i) { + error = lodepng_palette_add(mode_out, p[i * 4 + 0], p[i * 4 + 1], p[i * 4 + 2], p[i * 4 + 3]); + if(error) break; + } + + mode_out->colortype = LCT_PALETTE; + mode_out->bitdepth = palettebits; + + if(mode_in->colortype == LCT_PALETTE && mode_in->palettesize >= mode_out->palettesize + && mode_in->bitdepth == mode_out->bitdepth) { + /*If input should have same palette colors, keep original to preserve its order and prevent conversion*/ + lodepng_color_mode_cleanup(mode_out); + lodepng_color_mode_copy(mode_out, mode_in); + } + } else /*8-bit or 16-bit per channel*/ { + mode_out->bitdepth = bits; + mode_out->colortype = alpha ? (gray_ok ? LCT_GREY_ALPHA : LCT_RGBA) + : (gray_ok ? LCT_GREY : LCT_RGB); + if(key) { + unsigned mask = (1u << mode_out->bitdepth) - 1u; /*stats always uses 16-bit, mask converts it*/ + mode_out->key_r = stats->key_r & mask; + mode_out->key_g = stats->key_g & mask; + mode_out->key_b = stats->key_b & mask; + mode_out->key_defined = 1; + } + } + + return error; +} + +#endif /* #ifdef LODEPNG_COMPILE_ENCODER */ + +/* +Paeth predictor, used by PNG filter type 4 +The parameters are of type short, but should come from unsigned chars, the shorts +are only needed to make the paeth calculation correct. +*/ +static unsigned char paethPredictor(short a, short b, short c) { + short pa = LODEPNG_ABS(b - c); + short pb = LODEPNG_ABS(a - c); + short pc = LODEPNG_ABS(a + b - c - c); + /* return input value associated with smallest of pa, pb, pc (with certain priority if equal) */ + if(pb < pa) { a = b; pa = pb; } + return (pc < pa) ? c : a; +} + +/*shared values used by multiple Adam7 related functions*/ + +static const unsigned ADAM7_IX[7] = { 0, 4, 0, 2, 0, 1, 0 }; /*x start values*/ +static const unsigned ADAM7_IY[7] = { 0, 0, 4, 0, 2, 0, 1 }; /*y start values*/ +static const unsigned ADAM7_DX[7] = { 8, 8, 4, 4, 2, 2, 1 }; /*x delta values*/ +static const unsigned ADAM7_DY[7] = { 8, 8, 8, 4, 4, 2, 2 }; /*y delta values*/ + +/* +Outputs various dimensions and positions in the image related to the Adam7 reduced images. +passw: output containing the width of the 7 passes +passh: output containing the height of the 7 passes +filter_passstart: output containing the index of the start and end of each + reduced image with filter bytes +padded_passstart output containing the index of the start and end of each + reduced image when without filter bytes but with padded scanlines +passstart: output containing the index of the start and end of each reduced + image without padding between scanlines, but still padding between the images +w, h: width and height of non-interlaced image +bpp: bits per pixel +"padded" is only relevant if bpp is less than 8 and a scanline or image does not + end at a full byte +*/ +static void Adam7_getpassvalues(unsigned passw[7], unsigned passh[7], size_t filter_passstart[8], + size_t padded_passstart[8], size_t passstart[8], unsigned w, unsigned h, unsigned bpp) { + /*the passstart values have 8 values: the 8th one indicates the byte after the end of the 7th (= last) pass*/ + unsigned i; + + /*calculate width and height in pixels of each pass*/ + for(i = 0; i != 7; ++i) { + passw[i] = (w + ADAM7_DX[i] - ADAM7_IX[i] - 1) / ADAM7_DX[i]; + passh[i] = (h + ADAM7_DY[i] - ADAM7_IY[i] - 1) / ADAM7_DY[i]; + if(passw[i] == 0) passh[i] = 0; + if(passh[i] == 0) passw[i] = 0; + } + + filter_passstart[0] = padded_passstart[0] = passstart[0] = 0; + for(i = 0; i != 7; ++i) { + /*if passw[i] is 0, it's 0 bytes, not 1 (no filtertype-byte)*/ + filter_passstart[i + 1] = filter_passstart[i] + + ((passw[i] && passh[i]) ? passh[i] * (1u + (passw[i] * bpp + 7u) / 8u) : 0); + /*bits padded if needed to fill full byte at end of each scanline*/ + padded_passstart[i + 1] = padded_passstart[i] + passh[i] * ((passw[i] * bpp + 7u) / 8u); + /*only padded at end of reduced image*/ + passstart[i + 1] = passstart[i] + (passh[i] * passw[i] * bpp + 7u) / 8u; + } +} + +#ifdef LODEPNG_COMPILE_DECODER + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / PNG Decoder / */ +/* ////////////////////////////////////////////////////////////////////////// */ + +/*read the information from the header and store it in the LodePNGInfo. return value is error*/ +unsigned lodepng_inspect(unsigned* w, unsigned* h, LodePNGState* state, + const unsigned char* in, size_t insize) { + unsigned width, height; + LodePNGInfo* info = &state->info_png; + if(insize == 0 || in == 0) { + CERROR_RETURN_ERROR(state->error, 48); /*error: the given data is empty*/ + } + if(insize < 33) { + CERROR_RETURN_ERROR(state->error, 27); /*error: the data length is smaller than the length of a PNG header*/ + } + + /*when decoding a new PNG image, make sure all parameters created after previous decoding are reset*/ + /* TODO: remove this. One should use a new LodePNGState for new sessions */ + lodepng_info_cleanup(info); + lodepng_info_init(info); + + if(in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 + || in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) { + CERROR_RETURN_ERROR(state->error, 28); /*error: the first 8 bytes are not the correct PNG signature*/ + } + if(lodepng_chunk_length(in + 8) != 13) { + CERROR_RETURN_ERROR(state->error, 94); /*error: header size must be 13 bytes*/ + } + if(!lodepng_chunk_type_equals(in + 8, "IHDR")) { + CERROR_RETURN_ERROR(state->error, 29); /*error: it doesn't start with a IHDR chunk!*/ + } + + /*read the values given in the header*/ + width = lodepng_read32bitInt(&in[16]); + height = lodepng_read32bitInt(&in[20]); + /*TODO: remove the undocumented feature that allows to give null pointers to width or height*/ + if(w) *w = width; + if(h) *h = height; + info->color.bitdepth = in[24]; + info->color.colortype = (LodePNGColorType)in[25]; + info->compression_method = in[26]; + info->filter_method = in[27]; + info->interlace_method = in[28]; + + /*errors returned only after the parsing so other values are still output*/ + + /*error: invalid image size*/ + if(width == 0 || height == 0) CERROR_RETURN_ERROR(state->error, 93); + /*error: invalid colortype or bitdepth combination*/ + state->error = checkColorValidity(info->color.colortype, info->color.bitdepth); + if(state->error) return state->error; + /*error: only compression method 0 is allowed in the specification*/ + if(info->compression_method != 0) CERROR_RETURN_ERROR(state->error, 32); + /*error: only filter method 0 is allowed in the specification*/ + if(info->filter_method != 0) CERROR_RETURN_ERROR(state->error, 33); + /*error: only interlace methods 0 and 1 exist in the specification*/ + if(info->interlace_method > 1) CERROR_RETURN_ERROR(state->error, 34); + + if(!state->decoder.ignore_crc) { + unsigned CRC = lodepng_read32bitInt(&in[29]); + unsigned checksum = lodepng_crc32(&in[12], 17); + if(CRC != checksum) { + CERROR_RETURN_ERROR(state->error, 57); /*invalid CRC*/ + } + } + + return state->error; +} + +static unsigned unfilterScanline(unsigned char* recon, const unsigned char* scanline, const unsigned char* precon, + size_t bytewidth, unsigned char filterType, size_t length) { + /* + For PNG filter method 0 + unfilter a PNG image scanline by scanline. when the pixels are smaller than 1 byte, + the filter works byte per byte (bytewidth = 1) + precon is the previous unfiltered scanline, recon the result, scanline the current one + the incoming scanlines do NOT include the filtertype byte, that one is given in the parameter filterType instead + recon and scanline MAY be the same memory address! precon must be disjoint. + */ + + size_t i; + switch(filterType) { + case 0: + for(i = 0; i != length; ++i) recon[i] = scanline[i]; + break; + case 1: + for(i = 0; i != bytewidth; ++i) recon[i] = scanline[i]; + for(i = bytewidth; i < length; ++i) recon[i] = scanline[i] + recon[i - bytewidth]; + break; + case 2: + if(precon) { + for(i = 0; i != length; ++i) recon[i] = scanline[i] + precon[i]; + } else { + for(i = 0; i != length; ++i) recon[i] = scanline[i]; + } + break; + case 3: + if(precon) { + for(i = 0; i != bytewidth; ++i) recon[i] = scanline[i] + (precon[i] >> 1u); + for(i = bytewidth; i < length; ++i) recon[i] = scanline[i] + ((recon[i - bytewidth] + precon[i]) >> 1u); + } else { + for(i = 0; i != bytewidth; ++i) recon[i] = scanline[i]; + for(i = bytewidth; i < length; ++i) recon[i] = scanline[i] + (recon[i - bytewidth] >> 1u); + } + break; + case 4: + if(precon) { + for(i = 0; i != bytewidth; ++i) { + recon[i] = (scanline[i] + precon[i]); /*paethPredictor(0, precon[i], 0) is always precon[i]*/ + } + + /* Unroll independent paths of the paeth predictor. A 6x and 8x version would also be possible but that + adds too much code. Whether this actually speeds anything up at all depends on compiler and settings. */ + if(bytewidth >= 4) { + for(; i + 3 < length; i += 4) { + size_t j = i - bytewidth; + unsigned char s0 = scanline[i + 0], s1 = scanline[i + 1], s2 = scanline[i + 2], s3 = scanline[i + 3]; + unsigned char r0 = recon[j + 0], r1 = recon[j + 1], r2 = recon[j + 2], r3 = recon[j + 3]; + unsigned char p0 = precon[i + 0], p1 = precon[i + 1], p2 = precon[i + 2], p3 = precon[i + 3]; + unsigned char q0 = precon[j + 0], q1 = precon[j + 1], q2 = precon[j + 2], q3 = precon[j + 3]; + recon[i + 0] = s0 + paethPredictor(r0, p0, q0); + recon[i + 1] = s1 + paethPredictor(r1, p1, q1); + recon[i + 2] = s2 + paethPredictor(r2, p2, q2); + recon[i + 3] = s3 + paethPredictor(r3, p3, q3); + } + } else if(bytewidth >= 3) { + for(; i + 2 < length; i += 3) { + size_t j = i - bytewidth; + unsigned char s0 = scanline[i + 0], s1 = scanline[i + 1], s2 = scanline[i + 2]; + unsigned char r0 = recon[j + 0], r1 = recon[j + 1], r2 = recon[j + 2]; + unsigned char p0 = precon[i + 0], p1 = precon[i + 1], p2 = precon[i + 2]; + unsigned char q0 = precon[j + 0], q1 = precon[j + 1], q2 = precon[j + 2]; + recon[i + 0] = s0 + paethPredictor(r0, p0, q0); + recon[i + 1] = s1 + paethPredictor(r1, p1, q1); + recon[i + 2] = s2 + paethPredictor(r2, p2, q2); + } + } else if(bytewidth >= 2) { + for(; i + 1 < length; i += 2) { + size_t j = i - bytewidth; + unsigned char s0 = scanline[i + 0], s1 = scanline[i + 1]; + unsigned char r0 = recon[j + 0], r1 = recon[j + 1]; + unsigned char p0 = precon[i + 0], p1 = precon[i + 1]; + unsigned char q0 = precon[j + 0], q1 = precon[j + 1]; + recon[i + 0] = s0 + paethPredictor(r0, p0, q0); + recon[i + 1] = s1 + paethPredictor(r1, p1, q1); + } + } + + for(; i != length; ++i) { + recon[i] = (scanline[i] + paethPredictor(recon[i - bytewidth], precon[i], precon[i - bytewidth])); + } + } else { + for(i = 0; i != bytewidth; ++i) { + recon[i] = scanline[i]; + } + for(i = bytewidth; i < length; ++i) { + /*paethPredictor(recon[i - bytewidth], 0, 0) is always recon[i - bytewidth]*/ + recon[i] = (scanline[i] + recon[i - bytewidth]); + } + } + break; + default: return 36; /*error: invalid filter type given*/ + } + return 0; +} + +static unsigned unfilter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp) { + /* + For PNG filter method 0 + this function unfilters a single image (e.g. without interlacing this is called once, with Adam7 seven times) + out must have enough bytes allocated already, in must have the scanlines + 1 filtertype byte per scanline + w and h are image dimensions or dimensions of reduced image, bpp is bits per pixel + in and out are allowed to be the same memory address (but aren't the same size since in has the extra filter bytes) + */ + + unsigned y; + unsigned char* prevline = 0; + + /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/ + size_t bytewidth = (bpp + 7u) / 8u; + /*the width of a scanline in bytes, not including the filter type*/ + size_t linebytes = lodepng_get_raw_size_idat(w, 1, bpp) - 1u; + + for(y = 0; y < h; ++y) { + size_t outindex = linebytes * y; + size_t inindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/ + unsigned char filterType = in[inindex]; + + CERROR_TRY_RETURN(unfilterScanline(&out[outindex], &in[inindex + 1], prevline, bytewidth, filterType, linebytes)); + + prevline = &out[outindex]; + } + + return 0; +} + +/* +in: Adam7 interlaced image, with no padding bits between scanlines, but between + reduced images so that each reduced image starts at a byte. +out: the same pixels, but re-ordered so that they're now a non-interlaced image with size w*h +bpp: bits per pixel +out has the following size in bits: w * h * bpp. +in is possibly bigger due to padding bits between reduced images. +out must be big enough AND must be 0 everywhere if bpp < 8 in the current implementation +(because that's likely a little bit faster) +NOTE: comments about padding bits are only relevant if bpp < 8 +*/ +static void Adam7_deinterlace(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp) { + unsigned passw[7], passh[7]; + size_t filter_passstart[8], padded_passstart[8], passstart[8]; + unsigned i; + + Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp); + + if(bpp >= 8) { + for(i = 0; i != 7; ++i) { + unsigned x, y, b; + size_t bytewidth = bpp / 8u; + for(y = 0; y < passh[i]; ++y) + for(x = 0; x < passw[i]; ++x) { + size_t pixelinstart = passstart[i] + (y * passw[i] + x) * bytewidth; + size_t pixeloutstart = ((ADAM7_IY[i] + (size_t)y * ADAM7_DY[i]) * (size_t)w + + ADAM7_IX[i] + (size_t)x * ADAM7_DX[i]) * bytewidth; + for(b = 0; b < bytewidth; ++b) { + out[pixeloutstart + b] = in[pixelinstart + b]; + } + } + } + } else /*bpp < 8: Adam7 with pixels < 8 bit is a bit trickier: with bit pointers*/ { + for(i = 0; i != 7; ++i) { + unsigned x, y, b; + unsigned ilinebits = bpp * passw[i]; + unsigned olinebits = bpp * w; + size_t obp, ibp; /*bit pointers (for out and in buffer)*/ + for(y = 0; y < passh[i]; ++y) + for(x = 0; x < passw[i]; ++x) { + ibp = (8 * passstart[i]) + (y * ilinebits + x * bpp); + obp = (ADAM7_IY[i] + (size_t)y * ADAM7_DY[i]) * olinebits + (ADAM7_IX[i] + (size_t)x * ADAM7_DX[i]) * bpp; + for(b = 0; b < bpp; ++b) { + unsigned char bit = readBitFromReversedStream(&ibp, in); + setBitOfReversedStream(&obp, out, bit); + } + } + } + } +} + +static void removePaddingBits(unsigned char* out, const unsigned char* in, + size_t olinebits, size_t ilinebits, unsigned h) { + /* + After filtering there are still padding bits if scanlines have non multiple of 8 bit amounts. They need + to be removed (except at last scanline of (Adam7-reduced) image) before working with pure image buffers + for the Adam7 code, the color convert code and the output to the user. + in and out are allowed to be the same buffer, in may also be higher but still overlapping; in must + have >= ilinebits*h bits, out must have >= olinebits*h bits, olinebits must be <= ilinebits + also used to move bits after earlier such operations happened, e.g. in a sequence of reduced images from Adam7 + only useful if (ilinebits - olinebits) is a value in the range 1..7 + */ + unsigned y; + size_t diff = ilinebits - olinebits; + size_t ibp = 0, obp = 0; /*input and output bit pointers*/ + for(y = 0; y < h; ++y) { + size_t x; + for(x = 0; x < olinebits; ++x) { + unsigned char bit = readBitFromReversedStream(&ibp, in); + setBitOfReversedStream(&obp, out, bit); + } + ibp += diff; + } +} + +/*out must be buffer big enough to contain full image, and in must contain the full decompressed data from +the IDAT chunks (with filter index bytes and possible padding bits) +return value is error*/ +static unsigned postProcessScanlines(unsigned char* out, unsigned char* in, + unsigned w, unsigned h, const LodePNGInfo* info_png) { + /* + This function converts the filtered-padded-interlaced data into pure 2D image buffer with the PNG's colortype. + Steps: + *) if no Adam7: 1) unfilter 2) remove padding bits (= possible extra bits per scanline if bpp < 8) + *) if adam7: 1) 7x unfilter 2) 7x remove padding bits 3) Adam7_deinterlace + NOTE: the in buffer will be overwritten with intermediate data! + */ + unsigned bpp = lodepng_get_bpp(&info_png->color); + if(bpp == 0) return 31; /*error: invalid colortype*/ + + if(info_png->interlace_method == 0) { + if(bpp < 8 && w * bpp != ((w * bpp + 7u) / 8u) * 8u) { + CERROR_TRY_RETURN(unfilter(in, in, w, h, bpp)); + removePaddingBits(out, in, w * bpp, ((w * bpp + 7u) / 8u) * 8u, h); + } + /*we can immediately filter into the out buffer, no other steps needed*/ + else CERROR_TRY_RETURN(unfilter(out, in, w, h, bpp)); + } else /*interlace_method is 1 (Adam7)*/ { + unsigned passw[7], passh[7]; size_t filter_passstart[8], padded_passstart[8], passstart[8]; + unsigned i; + + Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp); + + for(i = 0; i != 7; ++i) { + CERROR_TRY_RETURN(unfilter(&in[padded_passstart[i]], &in[filter_passstart[i]], passw[i], passh[i], bpp)); + /*TODO: possible efficiency improvement: if in this reduced image the bits fit nicely in 1 scanline, + move bytes instead of bits or move not at all*/ + if(bpp < 8) { + /*remove padding bits in scanlines; after this there still may be padding + bits between the different reduced images: each reduced image still starts nicely at a byte*/ + removePaddingBits(&in[passstart[i]], &in[padded_passstart[i]], passw[i] * bpp, + ((passw[i] * bpp + 7u) / 8u) * 8u, passh[i]); + } + } + + Adam7_deinterlace(out, in, w, h, bpp); + } + + return 0; +} + +static unsigned readChunk_PLTE(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength) { + unsigned pos = 0, i; + color->palettesize = chunkLength / 3u; + if(color->palettesize == 0 || color->palettesize > 256) return 38; /*error: palette too small or big*/ + lodepng_color_mode_alloc_palette(color); + if(!color->palette && color->palettesize) { + color->palettesize = 0; + return 83; /*alloc fail*/ + } + + for(i = 0; i != color->palettesize; ++i) { + color->palette[4 * i + 0] = data[pos++]; /*R*/ + color->palette[4 * i + 1] = data[pos++]; /*G*/ + color->palette[4 * i + 2] = data[pos++]; /*B*/ + color->palette[4 * i + 3] = 255; /*alpha*/ + } + + return 0; /* OK */ +} + +static unsigned readChunk_tRNS(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength) { + unsigned i; + if(color->colortype == LCT_PALETTE) { + /*error: more alpha values given than there are palette entries*/ + if(chunkLength > color->palettesize) return 39; + + for(i = 0; i != chunkLength; ++i) color->palette[4 * i + 3] = data[i]; + } else if(color->colortype == LCT_GREY) { + /*error: this chunk must be 2 bytes for grayscale image*/ + if(chunkLength != 2) return 30; + + color->key_defined = 1; + color->key_r = color->key_g = color->key_b = 256u * data[0] + data[1]; + } else if(color->colortype == LCT_RGB) { + /*error: this chunk must be 6 bytes for RGB image*/ + if(chunkLength != 6) return 41; + + color->key_defined = 1; + color->key_r = 256u * data[0] + data[1]; + color->key_g = 256u * data[2] + data[3]; + color->key_b = 256u * data[4] + data[5]; + } + else return 42; /*error: tRNS chunk not allowed for other color models*/ + + return 0; /* OK */ +} + + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS +/*background color chunk (bKGD)*/ +static unsigned readChunk_bKGD(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) { + if(info->color.colortype == LCT_PALETTE) { + /*error: this chunk must be 1 byte for indexed color image*/ + if(chunkLength != 1) return 43; + + /*error: invalid palette index, or maybe this chunk appeared before PLTE*/ + if(data[0] >= info->color.palettesize) return 103; + + info->background_defined = 1; + info->background_r = info->background_g = info->background_b = data[0]; + } else if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA) { + /*error: this chunk must be 2 bytes for grayscale image*/ + if(chunkLength != 2) return 44; + + /*the values are truncated to bitdepth in the PNG file*/ + info->background_defined = 1; + info->background_r = info->background_g = info->background_b = 256u * data[0] + data[1]; + } else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA) { + /*error: this chunk must be 6 bytes for grayscale image*/ + if(chunkLength != 6) return 45; + + /*the values are truncated to bitdepth in the PNG file*/ + info->background_defined = 1; + info->background_r = 256u * data[0] + data[1]; + info->background_g = 256u * data[2] + data[3]; + info->background_b = 256u * data[4] + data[5]; + } + + return 0; /* OK */ +} + +/*text chunk (tEXt)*/ +static unsigned readChunk_tEXt(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) { + unsigned error = 0; + char *key = 0, *str = 0; + + while(!error) /*not really a while loop, only used to break on error*/ { + unsigned length, string2_begin; + + length = 0; + while(length < chunkLength && data[length] != 0) ++length; + /*even though it's not allowed by the standard, no error is thrown if + there's no null termination char, if the text is empty*/ + if(length < 1 || length > 79) CERROR_BREAK(error, 89); /*keyword too short or long*/ + + key = (char*)lodepng_malloc(length + 1); + if(!key) CERROR_BREAK(error, 83); /*alloc fail*/ + + lodepng_memcpy(key, data, length); + key[length] = 0; + + string2_begin = length + 1; /*skip keyword null terminator*/ + + length = (unsigned)(chunkLength < string2_begin ? 0 : chunkLength - string2_begin); + str = (char*)lodepng_malloc(length + 1); + if(!str) CERROR_BREAK(error, 83); /*alloc fail*/ + + lodepng_memcpy(str, data + string2_begin, length); + str[length] = 0; + + error = lodepng_add_text(info, key, str); + + break; + } + + lodepng_free(key); + lodepng_free(str); + + return error; +} + +/*compressed text chunk (zTXt)*/ +static unsigned readChunk_zTXt(LodePNGInfo* info, const LodePNGDecoderSettings* decoder, + const unsigned char* data, size_t chunkLength) { + unsigned error = 0; + + /*copy the object to change parameters in it*/ + LodePNGDecompressSettings zlibsettings = decoder->zlibsettings; + + unsigned length, string2_begin; + char *key = 0; + unsigned char* str = 0; + size_t size = 0; + + while(!error) /*not really a while loop, only used to break on error*/ { + for(length = 0; length < chunkLength && data[length] != 0; ++length) ; + if(length + 2 >= chunkLength) CERROR_BREAK(error, 75); /*no null termination, corrupt?*/ + if(length < 1 || length > 79) CERROR_BREAK(error, 89); /*keyword too short or long*/ + + key = (char*)lodepng_malloc(length + 1); + if(!key) CERROR_BREAK(error, 83); /*alloc fail*/ + + lodepng_memcpy(key, data, length); + key[length] = 0; + + if(data[length + 1] != 0) CERROR_BREAK(error, 72); /*the 0 byte indicating compression must be 0*/ + + string2_begin = length + 2; + if(string2_begin > chunkLength) CERROR_BREAK(error, 75); /*no null termination, corrupt?*/ + + length = (unsigned)chunkLength - string2_begin; + zlibsettings.max_output_size = decoder->max_text_size; + /*will fail if zlib error, e.g. if length is too small*/ + error = zlib_decompress(&str, &size, 0, &data[string2_begin], + length, &zlibsettings); + /*error: compressed text larger than decoder->max_text_size*/ + if(error && size > zlibsettings.max_output_size) error = 112; + if(error) break; + error = lodepng_add_text_sized(info, key, (char*)str, size); + break; + } + + lodepng_free(key); + lodepng_free(str); + + return error; +} + +/*international text chunk (iTXt)*/ +static unsigned readChunk_iTXt(LodePNGInfo* info, const LodePNGDecoderSettings* decoder, + const unsigned char* data, size_t chunkLength) { + unsigned error = 0; + unsigned i; + + /*copy the object to change parameters in it*/ + LodePNGDecompressSettings zlibsettings = decoder->zlibsettings; + + unsigned length, begin, compressed; + char *key = 0, *langtag = 0, *transkey = 0; + + while(!error) /*not really a while loop, only used to break on error*/ { + /*Quick check if the chunk length isn't too small. Even without check + it'd still fail with other error checks below if it's too short. This just gives a different error code.*/ + if(chunkLength < 5) CERROR_BREAK(error, 30); /*iTXt chunk too short*/ + + /*read the key*/ + for(length = 0; length < chunkLength && data[length] != 0; ++length) ; + if(length + 3 >= chunkLength) CERROR_BREAK(error, 75); /*no null termination char, corrupt?*/ + if(length < 1 || length > 79) CERROR_BREAK(error, 89); /*keyword too short or long*/ + + key = (char*)lodepng_malloc(length + 1); + if(!key) CERROR_BREAK(error, 83); /*alloc fail*/ + + lodepng_memcpy(key, data, length); + key[length] = 0; + + /*read the compression method*/ + compressed = data[length + 1]; + if(data[length + 2] != 0) CERROR_BREAK(error, 72); /*the 0 byte indicating compression must be 0*/ + + /*even though it's not allowed by the standard, no error is thrown if + there's no null termination char, if the text is empty for the next 3 texts*/ + + /*read the langtag*/ + begin = length + 3; + length = 0; + for(i = begin; i < chunkLength && data[i] != 0; ++i) ++length; + + langtag = (char*)lodepng_malloc(length + 1); + if(!langtag) CERROR_BREAK(error, 83); /*alloc fail*/ + + lodepng_memcpy(langtag, data + begin, length); + langtag[length] = 0; + + /*read the transkey*/ + begin += length + 1; + length = 0; + for(i = begin; i < chunkLength && data[i] != 0; ++i) ++length; + + transkey = (char*)lodepng_malloc(length + 1); + if(!transkey) CERROR_BREAK(error, 83); /*alloc fail*/ + + lodepng_memcpy(transkey, data + begin, length); + transkey[length] = 0; + + /*read the actual text*/ + begin += length + 1; + + length = (unsigned)chunkLength < begin ? 0 : (unsigned)chunkLength - begin; + + if(compressed) { + unsigned char* str = 0; + size_t size = 0; + zlibsettings.max_output_size = decoder->max_text_size; + /*will fail if zlib error, e.g. if length is too small*/ + error = zlib_decompress(&str, &size, 0, &data[begin], + length, &zlibsettings); + /*error: compressed text larger than decoder->max_text_size*/ + if(error && size > zlibsettings.max_output_size) error = 112; + if(!error) error = lodepng_add_itext_sized(info, key, langtag, transkey, (char*)str, size); + lodepng_free(str); + } else { + error = lodepng_add_itext_sized(info, key, langtag, transkey, (char*)(data + begin), length); + } + + break; + } + + lodepng_free(key); + lodepng_free(langtag); + lodepng_free(transkey); + + return error; +} + +static unsigned readChunk_tIME(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) { + if(chunkLength != 7) return 73; /*invalid tIME chunk size*/ + + info->time_defined = 1; + info->time.year = 256u * data[0] + data[1]; + info->time.month = data[2]; + info->time.day = data[3]; + info->time.hour = data[4]; + info->time.minute = data[5]; + info->time.second = data[6]; + + return 0; /* OK */ +} + +static unsigned readChunk_pHYs(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) { + if(chunkLength != 9) return 74; /*invalid pHYs chunk size*/ + + info->phys_defined = 1; + info->phys_x = 16777216u * data[0] + 65536u * data[1] + 256u * data[2] + data[3]; + info->phys_y = 16777216u * data[4] + 65536u * data[5] + 256u * data[6] + data[7]; + info->phys_unit = data[8]; + + return 0; /* OK */ +} + +static unsigned readChunk_gAMA(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) { + if(chunkLength != 4) return 96; /*invalid gAMA chunk size*/ + + info->gama_defined = 1; + info->gama_gamma = 16777216u * data[0] + 65536u * data[1] + 256u * data[2] + data[3]; + + return 0; /* OK */ +} + +static unsigned readChunk_cHRM(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) { + if(chunkLength != 32) return 97; /*invalid cHRM chunk size*/ + + info->chrm_defined = 1; + info->chrm_white_x = 16777216u * data[ 0] + 65536u * data[ 1] + 256u * data[ 2] + data[ 3]; + info->chrm_white_y = 16777216u * data[ 4] + 65536u * data[ 5] + 256u * data[ 6] + data[ 7]; + info->chrm_red_x = 16777216u * data[ 8] + 65536u * data[ 9] + 256u * data[10] + data[11]; + info->chrm_red_y = 16777216u * data[12] + 65536u * data[13] + 256u * data[14] + data[15]; + info->chrm_green_x = 16777216u * data[16] + 65536u * data[17] + 256u * data[18] + data[19]; + info->chrm_green_y = 16777216u * data[20] + 65536u * data[21] + 256u * data[22] + data[23]; + info->chrm_blue_x = 16777216u * data[24] + 65536u * data[25] + 256u * data[26] + data[27]; + info->chrm_blue_y = 16777216u * data[28] + 65536u * data[29] + 256u * data[30] + data[31]; + + return 0; /* OK */ +} + +static unsigned readChunk_sRGB(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) { + if(chunkLength != 1) return 98; /*invalid sRGB chunk size (this one is never ignored)*/ + + info->srgb_defined = 1; + info->srgb_intent = data[0]; + + return 0; /* OK */ +} + +static unsigned readChunk_iCCP(LodePNGInfo* info, const LodePNGDecoderSettings* decoder, + const unsigned char* data, size_t chunkLength) { + unsigned error = 0; + unsigned i; + size_t size = 0; + /*copy the object to change parameters in it*/ + LodePNGDecompressSettings zlibsettings = decoder->zlibsettings; + + unsigned length, string2_begin; + + info->iccp_defined = 1; + if(info->iccp_name) lodepng_clear_icc(info); + + for(length = 0; length < chunkLength && data[length] != 0; ++length) ; + if(length + 2 >= chunkLength) return 75; /*no null termination, corrupt?*/ + if(length < 1 || length > 79) return 89; /*keyword too short or long*/ + + info->iccp_name = (char*)lodepng_malloc(length + 1); + if(!info->iccp_name) return 83; /*alloc fail*/ + + info->iccp_name[length] = 0; + for(i = 0; i != length; ++i) info->iccp_name[i] = (char)data[i]; + + if(data[length + 1] != 0) return 72; /*the 0 byte indicating compression must be 0*/ + + string2_begin = length + 2; + if(string2_begin > chunkLength) return 75; /*no null termination, corrupt?*/ + + length = (unsigned)chunkLength - string2_begin; + zlibsettings.max_output_size = decoder->max_icc_size; + error = zlib_decompress(&info->iccp_profile, &size, 0, + &data[string2_begin], + length, &zlibsettings); + /*error: ICC profile larger than decoder->max_icc_size*/ + if(error && size > zlibsettings.max_output_size) error = 113; + info->iccp_profile_size = size; + if(!error && !info->iccp_profile_size) error = 100; /*invalid ICC profile size*/ + return error; +} +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + +unsigned lodepng_inspect_chunk(LodePNGState* state, size_t pos, + const unsigned char* in, size_t insize) { + const unsigned char* chunk = in + pos; + unsigned chunkLength; + const unsigned char* data; + unsigned unhandled = 0; + unsigned error = 0; + + if(pos + 4 > insize) return 30; + chunkLength = lodepng_chunk_length(chunk); + if(chunkLength > 2147483647) return 63; + data = lodepng_chunk_data_const(chunk); + if(data + chunkLength + 4 > in + insize) return 30; + + if(lodepng_chunk_type_equals(chunk, "PLTE")) { + error = readChunk_PLTE(&state->info_png.color, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "tRNS")) { + error = readChunk_tRNS(&state->info_png.color, data, chunkLength); +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + } else if(lodepng_chunk_type_equals(chunk, "bKGD")) { + error = readChunk_bKGD(&state->info_png, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "tEXt")) { + error = readChunk_tEXt(&state->info_png, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "zTXt")) { + error = readChunk_zTXt(&state->info_png, &state->decoder, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "iTXt")) { + error = readChunk_iTXt(&state->info_png, &state->decoder, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "tIME")) { + error = readChunk_tIME(&state->info_png, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "pHYs")) { + error = readChunk_pHYs(&state->info_png, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "gAMA")) { + error = readChunk_gAMA(&state->info_png, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "cHRM")) { + error = readChunk_cHRM(&state->info_png, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "sRGB")) { + error = readChunk_sRGB(&state->info_png, data, chunkLength); + } else if(lodepng_chunk_type_equals(chunk, "iCCP")) { + error = readChunk_iCCP(&state->info_png, &state->decoder, data, chunkLength); +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + } else { + /* unhandled chunk is ok (is not an error) */ + unhandled = 1; + } + + if(!error && !unhandled && !state->decoder.ignore_crc) { + if(lodepng_chunk_check_crc(chunk)) return 57; /*invalid CRC*/ + } + + return error; +} + +/*read a PNG, the result will be in the same color type as the PNG (hence "generic")*/ +static void decodeGeneric(unsigned char** out, unsigned* w, unsigned* h, + LodePNGState* state, + const unsigned char* in, size_t insize) { + unsigned char IEND = 0; + const unsigned char* chunk; + unsigned char* idat; /*the data from idat chunks, zlib compressed*/ + size_t idatsize = 0; + unsigned char* scanlines = 0; + size_t scanlines_size = 0, expected_size = 0; + size_t outsize = 0; + + /*for unknown chunk order*/ + unsigned unknown = 0; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + unsigned critical_pos = 1; /*1 = after IHDR, 2 = after PLTE, 3 = after IDAT*/ +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + + + /* safe output values in case error happens */ + *out = 0; + *w = *h = 0; + + state->error = lodepng_inspect(w, h, state, in, insize); /*reads header and resets other parameters in state->info_png*/ + if(state->error) return; + + if(lodepng_pixel_overflow(*w, *h, &state->info_png.color, &state->info_raw)) { + CERROR_RETURN(state->error, 92); /*overflow possible due to amount of pixels*/ + } + + /*the input filesize is a safe upper bound for the sum of idat chunks size*/ + idat = (unsigned char*)lodepng_malloc(insize); + if(!idat) CERROR_RETURN(state->error, 83); /*alloc fail*/ + + chunk = &in[33]; /*first byte of the first chunk after the header*/ + + /*loop through the chunks, ignoring unknown chunks and stopping at IEND chunk. + IDAT data is put at the start of the in buffer*/ + while(!IEND && !state->error) { + unsigned chunkLength; + const unsigned char* data; /*the data in the chunk*/ + + /*error: size of the in buffer too small to contain next chunk*/ + if((size_t)((chunk - in) + 12) > insize || chunk < in) { + if(state->decoder.ignore_end) break; /*other errors may still happen though*/ + CERROR_BREAK(state->error, 30); + } + + /*length of the data of the chunk, excluding the length bytes, chunk type and CRC bytes*/ + chunkLength = lodepng_chunk_length(chunk); + /*error: chunk length larger than the max PNG chunk size*/ + if(chunkLength > 2147483647) { + if(state->decoder.ignore_end) break; /*other errors may still happen though*/ + CERROR_BREAK(state->error, 63); + } + + if((size_t)((chunk - in) + chunkLength + 12) > insize || (chunk + chunkLength + 12) < in) { + CERROR_BREAK(state->error, 64); /*error: size of the in buffer too small to contain next chunk*/ + } + + data = lodepng_chunk_data_const(chunk); + + unknown = 0; + + /*IDAT chunk, containing compressed image data*/ + if(lodepng_chunk_type_equals(chunk, "IDAT")) { + size_t newsize; + if(lodepng_addofl(idatsize, chunkLength, &newsize)) CERROR_BREAK(state->error, 95); + if(newsize > insize) CERROR_BREAK(state->error, 95); + lodepng_memcpy(idat + idatsize, data, chunkLength); + idatsize += chunkLength; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + critical_pos = 3; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + } else if(lodepng_chunk_type_equals(chunk, "IEND")) { + /*IEND chunk*/ + IEND = 1; + } else if(lodepng_chunk_type_equals(chunk, "PLTE")) { + /*palette chunk (PLTE)*/ + state->error = readChunk_PLTE(&state->info_png.color, data, chunkLength); + if(state->error) break; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + critical_pos = 2; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + } else if(lodepng_chunk_type_equals(chunk, "tRNS")) { + /*palette transparency chunk (tRNS). Even though this one is an ancillary chunk , it is still compiled + in without 'LODEPNG_COMPILE_ANCILLARY_CHUNKS' because it contains essential color information that + affects the alpha channel of pixels. */ + state->error = readChunk_tRNS(&state->info_png.color, data, chunkLength); + if(state->error) break; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + /*background color chunk (bKGD)*/ + } else if(lodepng_chunk_type_equals(chunk, "bKGD")) { + state->error = readChunk_bKGD(&state->info_png, data, chunkLength); + if(state->error) break; + } else if(lodepng_chunk_type_equals(chunk, "tEXt")) { + /*text chunk (tEXt)*/ + if(state->decoder.read_text_chunks) { + state->error = readChunk_tEXt(&state->info_png, data, chunkLength); + if(state->error) break; + } + } else if(lodepng_chunk_type_equals(chunk, "zTXt")) { + /*compressed text chunk (zTXt)*/ + if(state->decoder.read_text_chunks) { + state->error = readChunk_zTXt(&state->info_png, &state->decoder, data, chunkLength); + if(state->error) break; + } + } else if(lodepng_chunk_type_equals(chunk, "iTXt")) { + /*international text chunk (iTXt)*/ + if(state->decoder.read_text_chunks) { + state->error = readChunk_iTXt(&state->info_png, &state->decoder, data, chunkLength); + if(state->error) break; + } + } else if(lodepng_chunk_type_equals(chunk, "tIME")) { + state->error = readChunk_tIME(&state->info_png, data, chunkLength); + if(state->error) break; + } else if(lodepng_chunk_type_equals(chunk, "pHYs")) { + state->error = readChunk_pHYs(&state->info_png, data, chunkLength); + if(state->error) break; + } else if(lodepng_chunk_type_equals(chunk, "gAMA")) { + state->error = readChunk_gAMA(&state->info_png, data, chunkLength); + if(state->error) break; + } else if(lodepng_chunk_type_equals(chunk, "cHRM")) { + state->error = readChunk_cHRM(&state->info_png, data, chunkLength); + if(state->error) break; + } else if(lodepng_chunk_type_equals(chunk, "sRGB")) { + state->error = readChunk_sRGB(&state->info_png, data, chunkLength); + if(state->error) break; + } else if(lodepng_chunk_type_equals(chunk, "iCCP")) { + state->error = readChunk_iCCP(&state->info_png, &state->decoder, data, chunkLength); + if(state->error) break; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + } else /*it's not an implemented chunk type, so ignore it: skip over the data*/ { + /*error: unknown critical chunk (5th bit of first byte of chunk type is 0)*/ + if(!state->decoder.ignore_critical && !lodepng_chunk_ancillary(chunk)) { + CERROR_BREAK(state->error, 69); + } + + unknown = 1; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + if(state->decoder.remember_unknown_chunks) { + state->error = lodepng_chunk_append(&state->info_png.unknown_chunks_data[critical_pos - 1], + &state->info_png.unknown_chunks_size[critical_pos - 1], chunk); + if(state->error) break; + } +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + } + + if(!state->decoder.ignore_crc && !unknown) /*check CRC if wanted, only on known chunk types*/ { + if(lodepng_chunk_check_crc(chunk)) CERROR_BREAK(state->error, 57); /*invalid CRC*/ + } + + if(!IEND) chunk = lodepng_chunk_next_const(chunk, in + insize); + } + + if(!state->error && state->info_png.color.colortype == LCT_PALETTE && !state->info_png.color.palette) { + state->error = 106; /* error: PNG file must have PLTE chunk if color type is palette */ + } + + if(!state->error) { + /*predict output size, to allocate exact size for output buffer to avoid more dynamic allocation. + If the decompressed size does not match the prediction, the image must be corrupt.*/ + if(state->info_png.interlace_method == 0) { + size_t bpp = lodepng_get_bpp(&state->info_png.color); + expected_size = lodepng_get_raw_size_idat(*w, *h, bpp); + } else { + size_t bpp = lodepng_get_bpp(&state->info_png.color); + /*Adam-7 interlaced: expected size is the sum of the 7 sub-images sizes*/ + expected_size = 0; + expected_size += lodepng_get_raw_size_idat((*w + 7) >> 3, (*h + 7) >> 3, bpp); + if(*w > 4) expected_size += lodepng_get_raw_size_idat((*w + 3) >> 3, (*h + 7) >> 3, bpp); + expected_size += lodepng_get_raw_size_idat((*w + 3) >> 2, (*h + 3) >> 3, bpp); + if(*w > 2) expected_size += lodepng_get_raw_size_idat((*w + 1) >> 2, (*h + 3) >> 2, bpp); + expected_size += lodepng_get_raw_size_idat((*w + 1) >> 1, (*h + 1) >> 2, bpp); + if(*w > 1) expected_size += lodepng_get_raw_size_idat((*w + 0) >> 1, (*h + 1) >> 1, bpp); + expected_size += lodepng_get_raw_size_idat((*w + 0), (*h + 0) >> 1, bpp); + } + + state->error = zlib_decompress(&scanlines, &scanlines_size, expected_size, idat, idatsize, &state->decoder.zlibsettings); + } + if(!state->error && scanlines_size != expected_size) state->error = 91; /*decompressed size doesn't match prediction*/ + lodepng_free(idat); + + if(!state->error) { + outsize = lodepng_get_raw_size(*w, *h, &state->info_png.color); + *out = (unsigned char*)lodepng_malloc(outsize); + if(!*out) state->error = 83; /*alloc fail*/ + } + if(!state->error) { + lodepng_memset(*out, 0, outsize); + state->error = postProcessScanlines(*out, scanlines, *w, *h, &state->info_png); + } + lodepng_free(scanlines); +} + +unsigned lodepng_decode(unsigned char** out, unsigned* w, unsigned* h, + LodePNGState* state, + const unsigned char* in, size_t insize) { + *out = 0; + decodeGeneric(out, w, h, state, in, insize); + if(state->error) return state->error; + if(!state->decoder.color_convert || lodepng_color_mode_equal(&state->info_raw, &state->info_png.color)) { + /*same color type, no copying or converting of data needed*/ + /*store the info_png color settings on the info_raw so that the info_raw still reflects what colortype + the raw image has to the end user*/ + if(!state->decoder.color_convert) { + state->error = lodepng_color_mode_copy(&state->info_raw, &state->info_png.color); + if(state->error) return state->error; + } + } else { /*color conversion needed*/ + unsigned char* data = *out; + size_t outsize; + + /*TODO: check if this works according to the statement in the documentation: "The converter can convert + from grayscale input color type, to 8-bit grayscale or grayscale with alpha"*/ + if(!(state->info_raw.colortype == LCT_RGB || state->info_raw.colortype == LCT_RGBA) + && !(state->info_raw.bitdepth == 8)) { + return 56; /*unsupported color mode conversion*/ + } + + outsize = lodepng_get_raw_size(*w, *h, &state->info_raw); + *out = (unsigned char*)lodepng_malloc(outsize); + if(!(*out)) { + state->error = 83; /*alloc fail*/ + } + else state->error = lodepng_convert(*out, data, &state->info_raw, + &state->info_png.color, *w, *h); + lodepng_free(data); + } + return state->error; +} + +unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, + size_t insize, LodePNGColorType colortype, unsigned bitdepth) { + unsigned error; + LodePNGState state; + lodepng_state_init(&state); + state.info_raw.colortype = colortype; + state.info_raw.bitdepth = bitdepth; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + /*disable reading things that this function doesn't output*/ + state.decoder.read_text_chunks = 0; + state.decoder.remember_unknown_chunks = 0; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + error = lodepng_decode(out, w, h, &state, in, insize); + lodepng_state_cleanup(&state); + return error; +} + +unsigned lodepng_decode32(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, size_t insize) { + return lodepng_decode_memory(out, w, h, in, insize, LCT_RGBA, 8); +} + +unsigned lodepng_decode24(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in, size_t insize) { + return lodepng_decode_memory(out, w, h, in, insize, LCT_RGB, 8); +} + +#ifdef LODEPNG_COMPILE_DISK +unsigned lodepng_decode_file(unsigned char** out, unsigned* w, unsigned* h, const char* filename, + LodePNGColorType colortype, unsigned bitdepth) { + unsigned char* buffer = 0; + size_t buffersize; + unsigned error; + /* safe output values in case error happens */ + *out = 0; + *w = *h = 0; + error = lodepng_load_file(&buffer, &buffersize, filename); + if(!error) error = lodepng_decode_memory(out, w, h, buffer, buffersize, colortype, bitdepth); + lodepng_free(buffer); + return error; +} + +unsigned lodepng_decode32_file(unsigned char** out, unsigned* w, unsigned* h, const char* filename) { + return lodepng_decode_file(out, w, h, filename, LCT_RGBA, 8); +} + +unsigned lodepng_decode24_file(unsigned char** out, unsigned* w, unsigned* h, const char* filename) { + return lodepng_decode_file(out, w, h, filename, LCT_RGB, 8); +} +#endif /*LODEPNG_COMPILE_DISK*/ + +void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings) { + settings->color_convert = 1; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + settings->read_text_chunks = 1; + settings->remember_unknown_chunks = 0; + settings->max_text_size = 16777216; + settings->max_icc_size = 16777216; /* 16MB is much more than enough for any reasonable ICC profile */ +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + settings->ignore_crc = 0; + settings->ignore_critical = 0; + settings->ignore_end = 0; + lodepng_decompress_settings_init(&settings->zlibsettings); +} + +#endif /*LODEPNG_COMPILE_DECODER*/ + +#if defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER) + +void lodepng_state_init(LodePNGState* state) { +#ifdef LODEPNG_COMPILE_DECODER + lodepng_decoder_settings_init(&state->decoder); +#endif /*LODEPNG_COMPILE_DECODER*/ +#ifdef LODEPNG_COMPILE_ENCODER + lodepng_encoder_settings_init(&state->encoder); +#endif /*LODEPNG_COMPILE_ENCODER*/ + lodepng_color_mode_init(&state->info_raw); + lodepng_info_init(&state->info_png); + state->error = 1; +} + +void lodepng_state_cleanup(LodePNGState* state) { + lodepng_color_mode_cleanup(&state->info_raw); + lodepng_info_cleanup(&state->info_png); +} + +void lodepng_state_copy(LodePNGState* dest, const LodePNGState* source) { + lodepng_state_cleanup(dest); + *dest = *source; + lodepng_color_mode_init(&dest->info_raw); + lodepng_info_init(&dest->info_png); + dest->error = lodepng_color_mode_copy(&dest->info_raw, &source->info_raw); if(dest->error) return; + dest->error = lodepng_info_copy(&dest->info_png, &source->info_png); if(dest->error) return; +} + +#endif /* defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER) */ + +#ifdef LODEPNG_COMPILE_ENCODER + +/* ////////////////////////////////////////////////////////////////////////// */ +/* / PNG Encoder / */ +/* ////////////////////////////////////////////////////////////////////////// */ + + +static unsigned writeSignature(ucvector* out) { + size_t pos = out->size; + const unsigned char signature[] = {137, 80, 78, 71, 13, 10, 26, 10}; + /*8 bytes PNG signature, aka the magic bytes*/ + if(!ucvector_resize(out, out->size + 8)) return 83; /*alloc fail*/ + lodepng_memcpy(out->data + pos, signature, 8); + return 0; +} + +static unsigned addChunk_IHDR(ucvector* out, unsigned w, unsigned h, + LodePNGColorType colortype, unsigned bitdepth, unsigned interlace_method) { + unsigned char *chunk, *data; + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 13, "IHDR")); + data = chunk + 8; + + lodepng_set32bitInt(data + 0, w); /*width*/ + lodepng_set32bitInt(data + 4, h); /*height*/ + data[8] = (unsigned char)bitdepth; /*bit depth*/ + data[9] = (unsigned char)colortype; /*color type*/ + data[10] = 0; /*compression method*/ + data[11] = 0; /*filter method*/ + data[12] = interlace_method; /*interlace method*/ + + lodepng_chunk_generate_crc(chunk); + return 0; +} + +/* only adds the chunk if needed (there is a key or palette with alpha) */ +static unsigned addChunk_PLTE(ucvector* out, const LodePNGColorMode* info) { + unsigned char* chunk; + size_t i, j = 8; + + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, info->palettesize * 3, "PLTE")); + + for(i = 0; i != info->palettesize; ++i) { + /*add all channels except alpha channel*/ + chunk[j++] = info->palette[i * 4 + 0]; + chunk[j++] = info->palette[i * 4 + 1]; + chunk[j++] = info->palette[i * 4 + 2]; + } + + lodepng_chunk_generate_crc(chunk); + return 0; +} + +static unsigned addChunk_tRNS(ucvector* out, const LodePNGColorMode* info) { + unsigned char* chunk = 0; + + if(info->colortype == LCT_PALETTE) { + size_t i, amount = info->palettesize; + /*the tail of palette values that all have 255 as alpha, does not have to be encoded*/ + for(i = info->palettesize; i != 0; --i) { + if(info->palette[4 * (i - 1) + 3] != 255) break; + --amount; + } + if(amount) { + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, amount, "tRNS")); + /*add the alpha channel values from the palette*/ + for(i = 0; i != amount; ++i) chunk[8 + i] = info->palette[4 * i + 3]; + } + } else if(info->colortype == LCT_GREY) { + if(info->key_defined) { + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 2, "tRNS")); + chunk[8] = (unsigned char)(info->key_r >> 8); + chunk[9] = (unsigned char)(info->key_r & 255); + } + } else if(info->colortype == LCT_RGB) { + if(info->key_defined) { + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 6, "tRNS")); + chunk[8] = (unsigned char)(info->key_r >> 8); + chunk[9] = (unsigned char)(info->key_r & 255); + chunk[10] = (unsigned char)(info->key_g >> 8); + chunk[11] = (unsigned char)(info->key_g & 255); + chunk[12] = (unsigned char)(info->key_b >> 8); + chunk[13] = (unsigned char)(info->key_b & 255); + } + } + + if(chunk) lodepng_chunk_generate_crc(chunk); + return 0; +} + +static unsigned addChunk_IDAT(ucvector* out, const unsigned char* data, size_t datasize, + LodePNGCompressSettings* zlibsettings) { + unsigned error = 0; + unsigned char* zlib = 0; + size_t zlibsize = 0; + + error = zlib_compress(&zlib, &zlibsize, data, datasize, zlibsettings); + if(!error) { + error = lodepng_chunk_createv(out, zlibsize, "IDAT", zlib); + } + lodepng_free(zlib); + return error; +} + +static unsigned addChunk_IEND(ucvector* out) { + return lodepng_chunk_createv(out, 0, "IEND", 0); +} + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + +static unsigned addChunk_tEXt(ucvector* out, const char* keyword, const char* textstring) { + unsigned char* chunk = 0; + size_t keysize = lodepng_strlen(keyword), textsize = lodepng_strlen(textstring); + size_t size = keysize + 1 + textsize; + if(keysize < 1 || keysize > 79) return 89; /*error: invalid keyword size*/ + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, size, "tEXt")); + lodepng_memcpy(chunk + 8, keyword, keysize); + chunk[8 + keysize] = 0; /*null termination char*/ + lodepng_memcpy(chunk + 9 + keysize, textstring, textsize); + lodepng_chunk_generate_crc(chunk); + return 0; +} + +static unsigned addChunk_zTXt(ucvector* out, const char* keyword, const char* textstring, + LodePNGCompressSettings* zlibsettings) { + unsigned error = 0; + unsigned char* chunk = 0; + unsigned char* compressed = 0; + size_t compressedsize = 0; + size_t textsize = lodepng_strlen(textstring); + size_t keysize = lodepng_strlen(keyword); + if(keysize < 1 || keysize > 79) return 89; /*error: invalid keyword size*/ + + error = zlib_compress(&compressed, &compressedsize, + (const unsigned char*)textstring, textsize, zlibsettings); + if(!error) { + size_t size = keysize + 2 + compressedsize; + error = lodepng_chunk_init(&chunk, out, size, "zTXt"); + } + if(!error) { + lodepng_memcpy(chunk + 8, keyword, keysize); + chunk[8 + keysize] = 0; /*null termination char*/ + chunk[9 + keysize] = 0; /*compression method: 0*/ + lodepng_memcpy(chunk + 10 + keysize, compressed, compressedsize); + lodepng_chunk_generate_crc(chunk); + } + + lodepng_free(compressed); + return error; +} + +static unsigned addChunk_iTXt(ucvector* out, unsigned compress, const char* keyword, const char* langtag, + const char* transkey, const char* textstring, LodePNGCompressSettings* zlibsettings) { + unsigned error = 0; + unsigned char* chunk = 0; + unsigned char* compressed = 0; + size_t compressedsize = 0; + size_t textsize = lodepng_strlen(textstring); + size_t keysize = lodepng_strlen(keyword), langsize = lodepng_strlen(langtag), transsize = lodepng_strlen(transkey); + + if(keysize < 1 || keysize > 79) return 89; /*error: invalid keyword size*/ + + if(compress) { + error = zlib_compress(&compressed, &compressedsize, + (const unsigned char*)textstring, textsize, zlibsettings); + } + if(!error) { + size_t size = keysize + 3 + langsize + 1 + transsize + 1 + (compress ? compressedsize : textsize); + error = lodepng_chunk_init(&chunk, out, size, "iTXt"); + } + if(!error) { + size_t pos = 8; + lodepng_memcpy(chunk + pos, keyword, keysize); + pos += keysize; + chunk[pos++] = 0; /*null termination char*/ + chunk[pos++] = (compress ? 1 : 0); /*compression flag*/ + chunk[pos++] = 0; /*compression method: 0*/ + lodepng_memcpy(chunk + pos, langtag, langsize); + pos += langsize; + chunk[pos++] = 0; /*null termination char*/ + lodepng_memcpy(chunk + pos, transkey, transsize); + pos += transsize; + chunk[pos++] = 0; /*null termination char*/ + if(compress) { + lodepng_memcpy(chunk + pos, compressed, compressedsize); + } else { + lodepng_memcpy(chunk + pos, textstring, textsize); + } + lodepng_chunk_generate_crc(chunk); + } + + lodepng_free(compressed); + return error; +} + +static unsigned addChunk_bKGD(ucvector* out, const LodePNGInfo* info) { + unsigned char* chunk = 0; + if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA) { + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 2, "bKGD")); + chunk[8] = (unsigned char)(info->background_r >> 8); + chunk[9] = (unsigned char)(info->background_r & 255); + } else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA) { + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 6, "bKGD")); + chunk[8] = (unsigned char)(info->background_r >> 8); + chunk[9] = (unsigned char)(info->background_r & 255); + chunk[10] = (unsigned char)(info->background_g >> 8); + chunk[11] = (unsigned char)(info->background_g & 255); + chunk[12] = (unsigned char)(info->background_b >> 8); + chunk[13] = (unsigned char)(info->background_b & 255); + } else if(info->color.colortype == LCT_PALETTE) { + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 1, "bKGD")); + chunk[8] = (unsigned char)(info->background_r & 255); /*palette index*/ + } + if(chunk) lodepng_chunk_generate_crc(chunk); + return 0; +} + +static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time) { + unsigned char* chunk; + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 7, "tIME")); + chunk[8] = (unsigned char)(time->year >> 8); + chunk[9] = (unsigned char)(time->year & 255); + chunk[10] = (unsigned char)time->month; + chunk[11] = (unsigned char)time->day; + chunk[12] = (unsigned char)time->hour; + chunk[13] = (unsigned char)time->minute; + chunk[14] = (unsigned char)time->second; + lodepng_chunk_generate_crc(chunk); + return 0; +} + +static unsigned addChunk_pHYs(ucvector* out, const LodePNGInfo* info) { + unsigned char* chunk; + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 9, "pHYs")); + lodepng_set32bitInt(chunk + 8, info->phys_x); + lodepng_set32bitInt(chunk + 12, info->phys_y); + chunk[16] = info->phys_unit; + lodepng_chunk_generate_crc(chunk); + return 0; +} + +static unsigned addChunk_gAMA(ucvector* out, const LodePNGInfo* info) { + unsigned char* chunk; + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 4, "gAMA")); + lodepng_set32bitInt(chunk + 8, info->gama_gamma); + lodepng_chunk_generate_crc(chunk); + return 0; +} + +static unsigned addChunk_cHRM(ucvector* out, const LodePNGInfo* info) { + unsigned char* chunk; + CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, 32, "cHRM")); + lodepng_set32bitInt(chunk + 8, info->chrm_white_x); + lodepng_set32bitInt(chunk + 12, info->chrm_white_y); + lodepng_set32bitInt(chunk + 16, info->chrm_red_x); + lodepng_set32bitInt(chunk + 20, info->chrm_red_y); + lodepng_set32bitInt(chunk + 24, info->chrm_green_x); + lodepng_set32bitInt(chunk + 28, info->chrm_green_y); + lodepng_set32bitInt(chunk + 32, info->chrm_blue_x); + lodepng_set32bitInt(chunk + 36, info->chrm_blue_y); + lodepng_chunk_generate_crc(chunk); + return 0; +} + +static unsigned addChunk_sRGB(ucvector* out, const LodePNGInfo* info) { + unsigned char data = info->srgb_intent; + return lodepng_chunk_createv(out, 1, "sRGB", &data); +} + +static unsigned addChunk_iCCP(ucvector* out, const LodePNGInfo* info, LodePNGCompressSettings* zlibsettings) { + unsigned error = 0; + unsigned char* chunk = 0; + unsigned char* compressed = 0; + size_t compressedsize = 0; + size_t keysize = lodepng_strlen(info->iccp_name); + + if(keysize < 1 || keysize > 79) return 89; /*error: invalid keyword size*/ + error = zlib_compress(&compressed, &compressedsize, + info->iccp_profile, info->iccp_profile_size, zlibsettings); + if(!error) { + size_t size = keysize + 2 + compressedsize; + error = lodepng_chunk_init(&chunk, out, size, "iCCP"); + } + if(!error) { + lodepng_memcpy(chunk + 8, info->iccp_name, keysize); + chunk[8 + keysize] = 0; /*null termination char*/ + chunk[9 + keysize] = 0; /*compression method: 0*/ + lodepng_memcpy(chunk + 10 + keysize, compressed, compressedsize); + lodepng_chunk_generate_crc(chunk); + } + + lodepng_free(compressed); + return error; +} + +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + +static void filterScanline(unsigned char* out, const unsigned char* scanline, const unsigned char* prevline, + size_t length, size_t bytewidth, unsigned char filterType) { + size_t i; + switch(filterType) { + case 0: /*None*/ + for(i = 0; i != length; ++i) out[i] = scanline[i]; + break; + case 1: /*Sub*/ + for(i = 0; i != bytewidth; ++i) out[i] = scanline[i]; + for(i = bytewidth; i < length; ++i) out[i] = scanline[i] - scanline[i - bytewidth]; + break; + case 2: /*Up*/ + if(prevline) { + for(i = 0; i != length; ++i) out[i] = scanline[i] - prevline[i]; + } else { + for(i = 0; i != length; ++i) out[i] = scanline[i]; + } + break; + case 3: /*Average*/ + if(prevline) { + for(i = 0; i != bytewidth; ++i) out[i] = scanline[i] - (prevline[i] >> 1); + for(i = bytewidth; i < length; ++i) out[i] = scanline[i] - ((scanline[i - bytewidth] + prevline[i]) >> 1); + } else { + for(i = 0; i != bytewidth; ++i) out[i] = scanline[i]; + for(i = bytewidth; i < length; ++i) out[i] = scanline[i] - (scanline[i - bytewidth] >> 1); + } + break; + case 4: /*Paeth*/ + if(prevline) { + /*paethPredictor(0, prevline[i], 0) is always prevline[i]*/ + for(i = 0; i != bytewidth; ++i) out[i] = (scanline[i] - prevline[i]); + for(i = bytewidth; i < length; ++i) { + out[i] = (scanline[i] - paethPredictor(scanline[i - bytewidth], prevline[i], prevline[i - bytewidth])); + } + } else { + for(i = 0; i != bytewidth; ++i) out[i] = scanline[i]; + /*paethPredictor(scanline[i - bytewidth], 0, 0) is always scanline[i - bytewidth]*/ + for(i = bytewidth; i < length; ++i) out[i] = (scanline[i] - scanline[i - bytewidth]); + } + break; + default: return; /*invalid filter type given*/ + } +} + +/* integer binary logarithm, max return value is 31 */ +static size_t ilog2(size_t i) { + size_t result = 0; + if(i >= 65536) { result += 16; i >>= 16; } + if(i >= 256) { result += 8; i >>= 8; } + if(i >= 16) { result += 4; i >>= 4; } + if(i >= 4) { result += 2; i >>= 2; } + if(i >= 2) { result += 1; /*i >>= 1;*/ } + return result; +} + +/* integer approximation for i * log2(i), helper function for LFS_ENTROPY */ +static size_t ilog2i(size_t i) { + size_t l; + if(i == 0) return 0; + l = ilog2(i); + /* approximate i*log2(i): l is integer logarithm, ((i - (1u << l)) << 1u) + linearly approximates the missing fractional part multiplied by i */ + return i * l + ((i - (1u << l)) << 1u); +} + +static unsigned filter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, + const LodePNGColorMode* color, const LodePNGEncoderSettings* settings) { + /* + For PNG filter method 0 + out must be a buffer with as size: h + (w * h * bpp + 7u) / 8u, because there are + the scanlines with 1 extra byte per scanline + */ + + unsigned bpp = lodepng_get_bpp(color); + /*the width of a scanline in bytes, not including the filter type*/ + size_t linebytes = lodepng_get_raw_size_idat(w, 1, bpp) - 1u; + + /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/ + size_t bytewidth = (bpp + 7u) / 8u; + const unsigned char* prevline = 0; + unsigned x, y; + unsigned error = 0; + LodePNGFilterStrategy strategy = settings->filter_strategy; + + /* + There is a heuristic called the minimum sum of absolute differences heuristic, suggested by the PNG standard: + * If the image type is Palette, or the bit depth is smaller than 8, then do not filter the image (i.e. + use fixed filtering, with the filter None). + * (The other case) If the image type is Grayscale or RGB (with or without Alpha), and the bit depth is + not smaller than 8, then use adaptive filtering heuristic as follows: independently for each row, apply + all five filters and select the filter that produces the smallest sum of absolute values per row. + This heuristic is used if filter strategy is LFS_MINSUM and filter_palette_zero is true. + + If filter_palette_zero is true and filter_strategy is not LFS_MINSUM, the above heuristic is followed, + but for "the other case", whatever strategy filter_strategy is set to instead of the minimum sum + heuristic is used. + */ + if(settings->filter_palette_zero && + (color->colortype == LCT_PALETTE || color->bitdepth < 8)) strategy = LFS_ZERO; + + if(bpp == 0) return 31; /*error: invalid color type*/ + + if(strategy >= LFS_ZERO && strategy <= LFS_FOUR) { + unsigned char type = (unsigned char)strategy; + for(y = 0; y != h; ++y) { + size_t outindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/ + size_t inindex = linebytes * y; + out[outindex] = type; /*filter type byte*/ + filterScanline(&out[outindex + 1], &in[inindex], prevline, linebytes, bytewidth, type); + prevline = &in[inindex]; + } + } else if(strategy == LFS_MINSUM) { + /*adaptive filtering*/ + unsigned char* attempt[5]; /*five filtering attempts, one for each filter type*/ + size_t smallest = 0; + unsigned char type, bestType = 0; + + for(type = 0; type != 5; ++type) { + attempt[type] = (unsigned char*)lodepng_malloc(linebytes); + if(!attempt[type]) error = 83; /*alloc fail*/ + } + + if(!error) { + for(y = 0; y != h; ++y) { + /*try the 5 filter types*/ + for(type = 0; type != 5; ++type) { + size_t sum = 0; + filterScanline(attempt[type], &in[y * linebytes], prevline, linebytes, bytewidth, type); + + /*calculate the sum of the result*/ + if(type == 0) { + for(x = 0; x != linebytes; ++x) sum += (unsigned char)(attempt[type][x]); + } else { + for(x = 0; x != linebytes; ++x) { + /*For differences, each byte should be treated as signed, values above 127 are negative + (converted to signed char). Filtertype 0 isn't a difference though, so use unsigned there. + This means filtertype 0 is almost never chosen, but that is justified.*/ + unsigned char s = attempt[type][x]; + sum += s < 128 ? s : (255U - s); + } + } + + /*check if this is smallest sum (or if type == 0 it's the first case so always store the values)*/ + if(type == 0 || sum < smallest) { + bestType = type; + smallest = sum; + } + } + + prevline = &in[y * linebytes]; + + /*now fill the out values*/ + out[y * (linebytes + 1)] = bestType; /*the first byte of a scanline will be the filter type*/ + for(x = 0; x != linebytes; ++x) out[y * (linebytes + 1) + 1 + x] = attempt[bestType][x]; + } + } + + for(type = 0; type != 5; ++type) lodepng_free(attempt[type]); + } else if(strategy == LFS_ENTROPY) { + unsigned char* attempt[5]; /*five filtering attempts, one for each filter type*/ + size_t bestSum = 0; + unsigned type, bestType = 0; + unsigned count[256]; + + for(type = 0; type != 5; ++type) { + attempt[type] = (unsigned char*)lodepng_malloc(linebytes); + if(!attempt[type]) error = 83; /*alloc fail*/ + } + + if(!error) { + for(y = 0; y != h; ++y) { + /*try the 5 filter types*/ + for(type = 0; type != 5; ++type) { + size_t sum = 0; + filterScanline(attempt[type], &in[y * linebytes], prevline, linebytes, bytewidth, type); + lodepng_memset(count, 0, 256 * sizeof(*count)); + for(x = 0; x != linebytes; ++x) ++count[attempt[type][x]]; + ++count[type]; /*the filter type itself is part of the scanline*/ + for(x = 0; x != 256; ++x) { + sum += ilog2i(count[x]); + } + /*check if this is smallest sum (or if type == 0 it's the first case so always store the values)*/ + if(type == 0 || sum > bestSum) { + bestType = type; + bestSum = sum; + } + } + + prevline = &in[y * linebytes]; + + /*now fill the out values*/ + out[y * (linebytes + 1)] = bestType; /*the first byte of a scanline will be the filter type*/ + for(x = 0; x != linebytes; ++x) out[y * (linebytes + 1) + 1 + x] = attempt[bestType][x]; + } + } + + for(type = 0; type != 5; ++type) lodepng_free(attempt[type]); + } else if(strategy == LFS_PREDEFINED) { + for(y = 0; y != h; ++y) { + size_t outindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/ + size_t inindex = linebytes * y; + unsigned char type = settings->predefined_filters[y]; + out[outindex] = type; /*filter type byte*/ + filterScanline(&out[outindex + 1], &in[inindex], prevline, linebytes, bytewidth, type); + prevline = &in[inindex]; + } + } else if(strategy == LFS_BRUTE_FORCE) { + /*brute force filter chooser. + deflate the scanline after every filter attempt to see which one deflates best. + This is very slow and gives only slightly smaller, sometimes even larger, result*/ + size_t size[5]; + unsigned char* attempt[5]; /*five filtering attempts, one for each filter type*/ + size_t smallest = 0; + unsigned type = 0, bestType = 0; + unsigned char* dummy; + LodePNGCompressSettings zlibsettings; + lodepng_memcpy(&zlibsettings, &settings->zlibsettings, sizeof(LodePNGCompressSettings)); + /*use fixed tree on the attempts so that the tree is not adapted to the filtertype on purpose, + to simulate the true case where the tree is the same for the whole image. Sometimes it gives + better result with dynamic tree anyway. Using the fixed tree sometimes gives worse, but in rare + cases better compression. It does make this a bit less slow, so it's worth doing this.*/ + zlibsettings.btype = 1; + /*a custom encoder likely doesn't read the btype setting and is optimized for complete PNG + images only, so disable it*/ + zlibsettings.custom_zlib = 0; + zlibsettings.custom_deflate = 0; + for(type = 0; type != 5; ++type) { + attempt[type] = (unsigned char*)lodepng_malloc(linebytes); + if(!attempt[type]) error = 83; /*alloc fail*/ + } + if(!error) { + for(y = 0; y != h; ++y) /*try the 5 filter types*/ { + for(type = 0; type != 5; ++type) { + unsigned testsize = (unsigned)linebytes; + /*if(testsize > 8) testsize /= 8;*/ /*it already works good enough by testing a part of the row*/ + + filterScanline(attempt[type], &in[y * linebytes], prevline, linebytes, bytewidth, type); + size[type] = 0; + dummy = 0; + zlib_compress(&dummy, &size[type], attempt[type], testsize, &zlibsettings); + lodepng_free(dummy); + /*check if this is smallest size (or if type == 0 it's the first case so always store the values)*/ + if(type == 0 || size[type] < smallest) { + bestType = type; + smallest = size[type]; + } + } + prevline = &in[y * linebytes]; + out[y * (linebytes + 1)] = bestType; /*the first byte of a scanline will be the filter type*/ + for(x = 0; x != linebytes; ++x) out[y * (linebytes + 1) + 1 + x] = attempt[bestType][x]; + } + } + for(type = 0; type != 5; ++type) lodepng_free(attempt[type]); + } + else return 88; /* unknown filter strategy */ + + return error; +} + +static void addPaddingBits(unsigned char* out, const unsigned char* in, + size_t olinebits, size_t ilinebits, unsigned h) { + /*The opposite of the removePaddingBits function + olinebits must be >= ilinebits*/ + unsigned y; + size_t diff = olinebits - ilinebits; + size_t obp = 0, ibp = 0; /*bit pointers*/ + for(y = 0; y != h; ++y) { + size_t x; + for(x = 0; x < ilinebits; ++x) { + unsigned char bit = readBitFromReversedStream(&ibp, in); + setBitOfReversedStream(&obp, out, bit); + } + /*obp += diff; --> no, fill in some value in the padding bits too, to avoid + "Use of uninitialised value of size ###" warning from valgrind*/ + for(x = 0; x != diff; ++x) setBitOfReversedStream(&obp, out, 0); + } +} + +/* +in: non-interlaced image with size w*h +out: the same pixels, but re-ordered according to PNG's Adam7 interlacing, with + no padding bits between scanlines, but between reduced images so that each + reduced image starts at a byte. +bpp: bits per pixel +there are no padding bits, not between scanlines, not between reduced images +in has the following size in bits: w * h * bpp. +out is possibly bigger due to padding bits between reduced images +NOTE: comments about padding bits are only relevant if bpp < 8 +*/ +static void Adam7_interlace(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp) { + unsigned passw[7], passh[7]; + size_t filter_passstart[8], padded_passstart[8], passstart[8]; + unsigned i; + + Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp); + + if(bpp >= 8) { + for(i = 0; i != 7; ++i) { + unsigned x, y, b; + size_t bytewidth = bpp / 8u; + for(y = 0; y < passh[i]; ++y) + for(x = 0; x < passw[i]; ++x) { + size_t pixelinstart = ((ADAM7_IY[i] + y * ADAM7_DY[i]) * w + ADAM7_IX[i] + x * ADAM7_DX[i]) * bytewidth; + size_t pixeloutstart = passstart[i] + (y * passw[i] + x) * bytewidth; + for(b = 0; b < bytewidth; ++b) { + out[pixeloutstart + b] = in[pixelinstart + b]; + } + } + } + } else /*bpp < 8: Adam7 with pixels < 8 bit is a bit trickier: with bit pointers*/ { + for(i = 0; i != 7; ++i) { + unsigned x, y, b; + unsigned ilinebits = bpp * passw[i]; + unsigned olinebits = bpp * w; + size_t obp, ibp; /*bit pointers (for out and in buffer)*/ + for(y = 0; y < passh[i]; ++y) + for(x = 0; x < passw[i]; ++x) { + ibp = (ADAM7_IY[i] + y * ADAM7_DY[i]) * olinebits + (ADAM7_IX[i] + x * ADAM7_DX[i]) * bpp; + obp = (8 * passstart[i]) + (y * ilinebits + x * bpp); + for(b = 0; b < bpp; ++b) { + unsigned char bit = readBitFromReversedStream(&ibp, in); + setBitOfReversedStream(&obp, out, bit); + } + } + } + } +} + +/*out must be buffer big enough to contain uncompressed IDAT chunk data, and in must contain the full image. +return value is error**/ +static unsigned preProcessScanlines(unsigned char** out, size_t* outsize, const unsigned char* in, + unsigned w, unsigned h, + const LodePNGInfo* info_png, const LodePNGEncoderSettings* settings) { + /* + This function converts the pure 2D image with the PNG's colortype, into filtered-padded-interlaced data. Steps: + *) if no Adam7: 1) add padding bits (= possible extra bits per scanline if bpp < 8) 2) filter + *) if adam7: 1) Adam7_interlace 2) 7x add padding bits 3) 7x filter + */ + unsigned bpp = lodepng_get_bpp(&info_png->color); + unsigned error = 0; + + if(info_png->interlace_method == 0) { + *outsize = h + (h * ((w * bpp + 7u) / 8u)); /*image size plus an extra byte per scanline + possible padding bits*/ + *out = (unsigned char*)lodepng_malloc(*outsize); + if(!(*out) && (*outsize)) error = 83; /*alloc fail*/ + + if(!error) { + /*non multiple of 8 bits per scanline, padding bits needed per scanline*/ + if(bpp < 8 && w * bpp != ((w * bpp + 7u) / 8u) * 8u) { + unsigned char* padded = (unsigned char*)lodepng_malloc(h * ((w * bpp + 7u) / 8u)); + if(!padded) error = 83; /*alloc fail*/ + if(!error) { + addPaddingBits(padded, in, ((w * bpp + 7u) / 8u) * 8u, w * bpp, h); + error = filter(*out, padded, w, h, &info_png->color, settings); + } + lodepng_free(padded); + } else { + /*we can immediately filter into the out buffer, no other steps needed*/ + error = filter(*out, in, w, h, &info_png->color, settings); + } + } + } else /*interlace_method is 1 (Adam7)*/ { + unsigned passw[7], passh[7]; + size_t filter_passstart[8], padded_passstart[8], passstart[8]; + unsigned char* adam7; + + Adam7_getpassvalues(passw, passh, filter_passstart, padded_passstart, passstart, w, h, bpp); + + *outsize = filter_passstart[7]; /*image size plus an extra byte per scanline + possible padding bits*/ + *out = (unsigned char*)lodepng_malloc(*outsize); + if(!(*out)) error = 83; /*alloc fail*/ + + adam7 = (unsigned char*)lodepng_malloc(passstart[7]); + if(!adam7 && passstart[7]) error = 83; /*alloc fail*/ + + if(!error) { + unsigned i; + + Adam7_interlace(adam7, in, w, h, bpp); + for(i = 0; i != 7; ++i) { + if(bpp < 8) { + unsigned char* padded = (unsigned char*)lodepng_malloc(padded_passstart[i + 1] - padded_passstart[i]); + if(!padded) ERROR_BREAK(83); /*alloc fail*/ + addPaddingBits(padded, &adam7[passstart[i]], + ((passw[i] * bpp + 7u) / 8u) * 8u, passw[i] * bpp, passh[i]); + error = filter(&(*out)[filter_passstart[i]], padded, + passw[i], passh[i], &info_png->color, settings); + lodepng_free(padded); + } else { + error = filter(&(*out)[filter_passstart[i]], &adam7[padded_passstart[i]], + passw[i], passh[i], &info_png->color, settings); + } + + if(error) break; + } + } + + lodepng_free(adam7); + } + + return error; +} + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS +static unsigned addUnknownChunks(ucvector* out, unsigned char* data, size_t datasize) { + unsigned char* inchunk = data; + while((size_t)(inchunk - data) < datasize) { + CERROR_TRY_RETURN(lodepng_chunk_append(&out->data, &out->size, inchunk)); + out->allocsize = out->size; /*fix the allocsize again*/ + inchunk = lodepng_chunk_next(inchunk, data + datasize); + } + return 0; +} + +static unsigned isGrayICCProfile(const unsigned char* profile, unsigned size) { + /* + It is a gray profile if bytes 16-19 are "GRAY", rgb profile if bytes 16-19 + are "RGB ". We do not perform any full parsing of the ICC profile here, other + than check those 4 bytes to grayscale profile. Other than that, validity of + the profile is not checked. This is needed only because the PNG specification + requires using a non-gray color model if there is an ICC profile with "RGB " + (sadly limiting compression opportunities if the input data is grayscale RGB + data), and requires using a gray color model if it is "GRAY". + */ + if(size < 20) return 0; + return profile[16] == 'G' && profile[17] == 'R' && profile[18] == 'A' && profile[19] == 'Y'; +} + +static unsigned isRGBICCProfile(const unsigned char* profile, unsigned size) { + /* See comment in isGrayICCProfile*/ + if(size < 20) return 0; + return profile[16] == 'R' && profile[17] == 'G' && profile[18] == 'B' && profile[19] == ' '; +} +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + +unsigned lodepng_encode(unsigned char** out, size_t* outsize, + const unsigned char* image, unsigned w, unsigned h, + LodePNGState* state) { + unsigned char* data = 0; /*uncompressed version of the IDAT chunk data*/ + size_t datasize = 0; + ucvector outv = ucvector_init(NULL, 0); + LodePNGInfo info; + const LodePNGInfo* info_png = &state->info_png; + + lodepng_info_init(&info); + + /*provide some proper output values if error will happen*/ + *out = 0; + *outsize = 0; + state->error = 0; + + /*check input values validity*/ + if((info_png->color.colortype == LCT_PALETTE || state->encoder.force_palette) + && (info_png->color.palettesize == 0 || info_png->color.palettesize > 256)) { + state->error = 68; /*invalid palette size, it is only allowed to be 1-256*/ + goto cleanup; + } + if(state->encoder.zlibsettings.btype > 2) { + state->error = 61; /*error: invalid btype*/ + goto cleanup; + } + if(info_png->interlace_method > 1) { + state->error = 71; /*error: invalid interlace mode*/ + goto cleanup; + } + state->error = checkColorValidity(info_png->color.colortype, info_png->color.bitdepth); + if(state->error) goto cleanup; /*error: invalid color type given*/ + state->error = checkColorValidity(state->info_raw.colortype, state->info_raw.bitdepth); + if(state->error) goto cleanup; /*error: invalid color type given*/ + + /* color convert and compute scanline filter types */ + lodepng_info_copy(&info, &state->info_png); + if(state->encoder.auto_convert) { + LodePNGColorStats stats; + lodepng_color_stats_init(&stats); +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + if(info_png->iccp_defined && + isGrayICCProfile(info_png->iccp_profile, info_png->iccp_profile_size)) { + /*the PNG specification does not allow to use palette with a GRAY ICC profile, even + if the palette has only gray colors, so disallow it.*/ + stats.allow_palette = 0; + } + if(info_png->iccp_defined && + isRGBICCProfile(info_png->iccp_profile, info_png->iccp_profile_size)) { + /*the PNG specification does not allow to use grayscale color with RGB ICC profile, so disallow gray.*/ + stats.allow_greyscale = 0; + } +#endif /* LODEPNG_COMPILE_ANCILLARY_CHUNKS */ + state->error = lodepng_compute_color_stats(&stats, image, w, h, &state->info_raw); + if(state->error) goto cleanup; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + if(info_png->background_defined) { + /*the background chunk's color must be taken into account as well*/ + unsigned r = 0, g = 0, b = 0; + LodePNGColorMode mode16 = lodepng_color_mode_make(LCT_RGB, 16); + lodepng_convert_rgb(&r, &g, &b, info_png->background_r, info_png->background_g, info_png->background_b, &mode16, &info_png->color); + state->error = lodepng_color_stats_add(&stats, r, g, b, 65535); + if(state->error) goto cleanup; + } +#endif /* LODEPNG_COMPILE_ANCILLARY_CHUNKS */ + state->error = auto_choose_color(&info.color, &state->info_raw, &stats); + if(state->error) goto cleanup; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + /*also convert the background chunk*/ + if(info_png->background_defined) { + if(lodepng_convert_rgb(&info.background_r, &info.background_g, &info.background_b, + info_png->background_r, info_png->background_g, info_png->background_b, &info.color, &info_png->color)) { + state->error = 104; + goto cleanup; + } + } +#endif /* LODEPNG_COMPILE_ANCILLARY_CHUNKS */ + } +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + if(info_png->iccp_defined) { + unsigned gray_icc = isGrayICCProfile(info_png->iccp_profile, info_png->iccp_profile_size); + unsigned rgb_icc = isRGBICCProfile(info_png->iccp_profile, info_png->iccp_profile_size); + unsigned gray_png = info.color.colortype == LCT_GREY || info.color.colortype == LCT_GREY_ALPHA; + if(!gray_icc && !rgb_icc) { + state->error = 100; /* Disallowed profile color type for PNG */ + goto cleanup; + } + if(gray_icc != gray_png) { + /*Not allowed to use RGB/RGBA/palette with GRAY ICC profile or vice versa, + or in case of auto_convert, it wasn't possible to find appropriate model*/ + state->error = state->encoder.auto_convert ? 102 : 101; + goto cleanup; + } + } +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + if(!lodepng_color_mode_equal(&state->info_raw, &info.color)) { + unsigned char* converted; + size_t size = ((size_t)w * (size_t)h * (size_t)lodepng_get_bpp(&info.color) + 7u) / 8u; + + converted = (unsigned char*)lodepng_malloc(size); + if(!converted && size) state->error = 83; /*alloc fail*/ + if(!state->error) { + state->error = lodepng_convert(converted, image, &info.color, &state->info_raw, w, h); + } + if(!state->error) { + state->error = preProcessScanlines(&data, &datasize, converted, w, h, &info, &state->encoder); + } + lodepng_free(converted); + if(state->error) goto cleanup; + } else { + state->error = preProcessScanlines(&data, &datasize, image, w, h, &info, &state->encoder); + if(state->error) goto cleanup; + } + + /* output all PNG chunks */ { +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + size_t i; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + /*write signature and chunks*/ + state->error = writeSignature(&outv); + if(state->error) goto cleanup; + /*IHDR*/ + state->error = addChunk_IHDR(&outv, w, h, info.color.colortype, info.color.bitdepth, info.interlace_method); + if(state->error) goto cleanup; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + /*unknown chunks between IHDR and PLTE*/ + if(info.unknown_chunks_data[0]) { + state->error = addUnknownChunks(&outv, info.unknown_chunks_data[0], info.unknown_chunks_size[0]); + if(state->error) goto cleanup; + } + /*color profile chunks must come before PLTE */ + if(info.iccp_defined) { + state->error = addChunk_iCCP(&outv, &info, &state->encoder.zlibsettings); + if(state->error) goto cleanup; + } + if(info.srgb_defined) { + state->error = addChunk_sRGB(&outv, &info); + if(state->error) goto cleanup; + } + if(info.gama_defined) { + state->error = addChunk_gAMA(&outv, &info); + if(state->error) goto cleanup; + } + if(info.chrm_defined) { + state->error = addChunk_cHRM(&outv, &info); + if(state->error) goto cleanup; + } +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + /*PLTE*/ + if(info.color.colortype == LCT_PALETTE) { + state->error = addChunk_PLTE(&outv, &info.color); + if(state->error) goto cleanup; + } + if(state->encoder.force_palette && (info.color.colortype == LCT_RGB || info.color.colortype == LCT_RGBA)) { + /*force_palette means: write suggested palette for truecolor in PLTE chunk*/ + state->error = addChunk_PLTE(&outv, &info.color); + if(state->error) goto cleanup; + } + /*tRNS (this will only add if when necessary) */ + state->error = addChunk_tRNS(&outv, &info.color); + if(state->error) goto cleanup; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + /*bKGD (must come between PLTE and the IDAt chunks*/ + if(info.background_defined) { + state->error = addChunk_bKGD(&outv, &info); + if(state->error) goto cleanup; + } + /*pHYs (must come before the IDAT chunks)*/ + if(info.phys_defined) { + state->error = addChunk_pHYs(&outv, &info); + if(state->error) goto cleanup; + } + + /*unknown chunks between PLTE and IDAT*/ + if(info.unknown_chunks_data[1]) { + state->error = addUnknownChunks(&outv, info.unknown_chunks_data[1], info.unknown_chunks_size[1]); + if(state->error) goto cleanup; + } +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + /*IDAT (multiple IDAT chunks must be consecutive)*/ + state->error = addChunk_IDAT(&outv, data, datasize, &state->encoder.zlibsettings); + if(state->error) goto cleanup; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + /*tIME*/ + if(info.time_defined) { + state->error = addChunk_tIME(&outv, &info.time); + if(state->error) goto cleanup; + } + /*tEXt and/or zTXt*/ + for(i = 0; i != info.text_num; ++i) { + if(lodepng_strlen(info.text_keys[i]) > 79) { + state->error = 66; /*text chunk too large*/ + goto cleanup; + } + if(lodepng_strlen(info.text_keys[i]) < 1) { + state->error = 67; /*text chunk too small*/ + goto cleanup; + } + if(state->encoder.text_compression) { + state->error = addChunk_zTXt(&outv, info.text_keys[i], info.text_strings[i], &state->encoder.zlibsettings); + if(state->error) goto cleanup; + } else { + state->error = addChunk_tEXt(&outv, info.text_keys[i], info.text_strings[i]); + if(state->error) goto cleanup; + } + } + /*LodePNG version id in text chunk*/ + if(state->encoder.add_id) { + unsigned already_added_id_text = 0; + for(i = 0; i != info.text_num; ++i) { + const char* k = info.text_keys[i]; + /* Could use strcmp, but we're not calling or reimplementing this C library function for this use only */ + if(k[0] == 'L' && k[1] == 'o' && k[2] == 'd' && k[3] == 'e' && + k[4] == 'P' && k[5] == 'N' && k[6] == 'G' && k[7] == '\0') { + already_added_id_text = 1; + break; + } + } + if(already_added_id_text == 0) { + state->error = addChunk_tEXt(&outv, "LodePNG", LODEPNG_VERSION_STRING); /*it's shorter as tEXt than as zTXt chunk*/ + if(state->error) goto cleanup; + } + } + /*iTXt*/ + for(i = 0; i != info.itext_num; ++i) { + if(lodepng_strlen(info.itext_keys[i]) > 79) { + state->error = 66; /*text chunk too large*/ + goto cleanup; + } + if(lodepng_strlen(info.itext_keys[i]) < 1) { + state->error = 67; /*text chunk too small*/ + goto cleanup; + } + state->error = addChunk_iTXt( + &outv, state->encoder.text_compression, + info.itext_keys[i], info.itext_langtags[i], info.itext_transkeys[i], info.itext_strings[i], + &state->encoder.zlibsettings); + if(state->error) goto cleanup; + } + + /*unknown chunks between IDAT and IEND*/ + if(info.unknown_chunks_data[2]) { + state->error = addUnknownChunks(&outv, info.unknown_chunks_data[2], info.unknown_chunks_size[2]); + if(state->error) goto cleanup; + } +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + state->error = addChunk_IEND(&outv); + if(state->error) goto cleanup; + } + +cleanup: + lodepng_info_cleanup(&info); + lodepng_free(data); + + /*instead of cleaning the vector up, give it to the output*/ + *out = outv.data; + *outsize = outv.size; + + return state->error; +} + +unsigned lodepng_encode_memory(unsigned char** out, size_t* outsize, const unsigned char* image, + unsigned w, unsigned h, LodePNGColorType colortype, unsigned bitdepth) { + unsigned error; + LodePNGState state; + lodepng_state_init(&state); + state.info_raw.colortype = colortype; + state.info_raw.bitdepth = bitdepth; + state.info_png.color.colortype = colortype; + state.info_png.color.bitdepth = bitdepth; + lodepng_encode(out, outsize, image, w, h, &state); + error = state.error; + lodepng_state_cleanup(&state); + return error; +} + +unsigned lodepng_encode32(unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h) { + return lodepng_encode_memory(out, outsize, image, w, h, LCT_RGBA, 8); +} + +unsigned lodepng_encode24(unsigned char** out, size_t* outsize, const unsigned char* image, unsigned w, unsigned h) { + return lodepng_encode_memory(out, outsize, image, w, h, LCT_RGB, 8); +} + +#ifdef LODEPNG_COMPILE_DISK +unsigned lodepng_encode_file(const char* filename, const unsigned char* image, unsigned w, unsigned h, + LodePNGColorType colortype, unsigned bitdepth) { + unsigned char* buffer; + size_t buffersize; + unsigned error = lodepng_encode_memory(&buffer, &buffersize, image, w, h, colortype, bitdepth); + if(!error) error = lodepng_save_file(buffer, buffersize, filename); + lodepng_free(buffer); + return error; +} + +unsigned lodepng_encode32_file(const char* filename, const unsigned char* image, unsigned w, unsigned h) { + return lodepng_encode_file(filename, image, w, h, LCT_RGBA, 8); +} + +unsigned lodepng_encode24_file(const char* filename, const unsigned char* image, unsigned w, unsigned h) { + return lodepng_encode_file(filename, image, w, h, LCT_RGB, 8); +} +#endif /*LODEPNG_COMPILE_DISK*/ + +void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings) { + lodepng_compress_settings_init(&settings->zlibsettings); + settings->filter_palette_zero = 1; + settings->filter_strategy = LFS_MINSUM; + settings->auto_convert = 1; + settings->force_palette = 0; + settings->predefined_filters = 0; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + settings->add_id = 0; + settings->text_compression = 1; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ +} + +#endif /*LODEPNG_COMPILE_ENCODER*/ +#endif /*LODEPNG_COMPILE_PNG*/ + +#ifdef LODEPNG_COMPILE_ERROR_TEXT +/* +This returns the description of a numerical error code in English. This is also +the documentation of all the error codes. +*/ +const char* lodepng_error_text(unsigned code) { + switch(code) { + case 0: return "no error, everything went ok"; + case 1: return "nothing done yet"; /*the Encoder/Decoder has done nothing yet, error checking makes no sense yet*/ + case 10: return "end of input memory reached without huffman end code"; /*while huffman decoding*/ + case 11: return "error in code tree made it jump outside of huffman tree"; /*while huffman decoding*/ + case 13: return "problem while processing dynamic deflate block"; + case 14: return "problem while processing dynamic deflate block"; + case 15: return "problem while processing dynamic deflate block"; + /*this error could happen if there are only 0 or 1 symbols present in the huffman code:*/ + case 16: return "invalid code while processing dynamic deflate block"; + case 17: return "end of out buffer memory reached while inflating"; + case 18: return "invalid distance code while inflating"; + case 19: return "end of out buffer memory reached while inflating"; + case 20: return "invalid deflate block BTYPE encountered while decoding"; + case 21: return "NLEN is not ones complement of LEN in a deflate block"; + + /*end of out buffer memory reached while inflating: + This can happen if the inflated deflate data is longer than the amount of bytes required to fill up + all the pixels of the image, given the color depth and image dimensions. Something that doesn't + happen in a normal, well encoded, PNG image.*/ + case 22: return "end of out buffer memory reached while inflating"; + case 23: return "end of in buffer memory reached while inflating"; + case 24: return "invalid FCHECK in zlib header"; + case 25: return "invalid compression method in zlib header"; + case 26: return "FDICT encountered in zlib header while it's not used for PNG"; + case 27: return "PNG file is smaller than a PNG header"; + /*Checks the magic file header, the first 8 bytes of the PNG file*/ + case 28: return "incorrect PNG signature, it's no PNG or corrupted"; + case 29: return "first chunk is not the header chunk"; + case 30: return "chunk length too large, chunk broken off at end of file"; + case 31: return "illegal PNG color type or bpp"; + case 32: return "illegal PNG compression method"; + case 33: return "illegal PNG filter method"; + case 34: return "illegal PNG interlace method"; + case 35: return "chunk length of a chunk is too large or the chunk too small"; + case 36: return "illegal PNG filter type encountered"; + case 37: return "illegal bit depth for this color type given"; + case 38: return "the palette is too small or too big"; /*0, or more than 256 colors*/ + case 39: return "tRNS chunk before PLTE or has more entries than palette size"; + case 40: return "tRNS chunk has wrong size for grayscale image"; + case 41: return "tRNS chunk has wrong size for RGB image"; + case 42: return "tRNS chunk appeared while it was not allowed for this color type"; + case 43: return "bKGD chunk has wrong size for palette image"; + case 44: return "bKGD chunk has wrong size for grayscale image"; + case 45: return "bKGD chunk has wrong size for RGB image"; + case 48: return "empty input buffer given to decoder. Maybe caused by non-existing file?"; + case 49: return "jumped past memory while generating dynamic huffman tree"; + case 50: return "jumped past memory while generating dynamic huffman tree"; + case 51: return "jumped past memory while inflating huffman block"; + case 52: return "jumped past memory while inflating"; + case 53: return "size of zlib data too small"; + case 54: return "repeat symbol in tree while there was no value symbol yet"; + /*jumped past tree while generating huffman tree, this could be when the + tree will have more leaves than symbols after generating it out of the + given lengths. They call this an oversubscribed dynamic bit lengths tree in zlib.*/ + case 55: return "jumped past tree while generating huffman tree"; + case 56: return "given output image colortype or bitdepth not supported for color conversion"; + case 57: return "invalid CRC encountered (checking CRC can be disabled)"; + case 58: return "invalid ADLER32 encountered (checking ADLER32 can be disabled)"; + case 59: return "requested color conversion not supported"; + case 60: return "invalid window size given in the settings of the encoder (must be 0-32768)"; + case 61: return "invalid BTYPE given in the settings of the encoder (only 0, 1 and 2 are allowed)"; + /*LodePNG leaves the choice of RGB to grayscale conversion formula to the user.*/ + case 62: return "conversion from color to grayscale not supported"; + /*(2^31-1)*/ + case 63: return "length of a chunk too long, max allowed for PNG is 2147483647 bytes per chunk"; + /*this would result in the inability of a deflated block to ever contain an end code. It must be at least 1.*/ + case 64: return "the length of the END symbol 256 in the Huffman tree is 0"; + case 66: return "the length of a text chunk keyword given to the encoder is longer than the maximum of 79 bytes"; + case 67: return "the length of a text chunk keyword given to the encoder is smaller than the minimum of 1 byte"; + case 68: return "tried to encode a PLTE chunk with a palette that has less than 1 or more than 256 colors"; + case 69: return "unknown chunk type with 'critical' flag encountered by the decoder"; + case 71: return "invalid interlace mode given to encoder (must be 0 or 1)"; + case 72: return "while decoding, invalid compression method encountering in zTXt or iTXt chunk (it must be 0)"; + case 73: return "invalid tIME chunk size"; + case 74: return "invalid pHYs chunk size"; + /*length could be wrong, or data chopped off*/ + case 75: return "no null termination char found while decoding text chunk"; + case 76: return "iTXt chunk too short to contain required bytes"; + case 77: return "integer overflow in buffer size"; + case 78: return "failed to open file for reading"; /*file doesn't exist or couldn't be opened for reading*/ + case 79: return "failed to open file for writing"; + case 80: return "tried creating a tree of 0 symbols"; + case 81: return "lazy matching at pos 0 is impossible"; + case 82: return "color conversion to palette requested while a color isn't in palette, or index out of bounds"; + case 83: return "memory allocation failed"; + case 84: return "given image too small to contain all pixels to be encoded"; + case 86: return "impossible offset in lz77 encoding (internal bug)"; + case 87: return "must provide custom zlib function pointer if LODEPNG_COMPILE_ZLIB is not defined"; + case 88: return "invalid filter strategy given for LodePNGEncoderSettings.filter_strategy"; + case 89: return "text chunk keyword too short or long: must have size 1-79"; + /*the windowsize in the LodePNGCompressSettings. Requiring POT(==> & instead of %) makes encoding 12% faster.*/ + case 90: return "windowsize must be a power of two"; + case 91: return "invalid decompressed idat size"; + case 92: return "integer overflow due to too many pixels"; + case 93: return "zero width or height is invalid"; + case 94: return "header chunk must have a size of 13 bytes"; + case 95: return "integer overflow with combined idat chunk size"; + case 96: return "invalid gAMA chunk size"; + case 97: return "invalid cHRM chunk size"; + case 98: return "invalid sRGB chunk size"; + case 99: return "invalid sRGB rendering intent"; + case 100: return "invalid ICC profile color type, the PNG specification only allows RGB or GRAY"; + case 101: return "PNG specification does not allow RGB ICC profile on gray color types and vice versa"; + case 102: return "not allowed to set grayscale ICC profile with colored pixels by PNG specification"; + case 103: return "invalid palette index in bKGD chunk. Maybe it came before PLTE chunk?"; + case 104: return "invalid bKGD color while encoding (e.g. palette index out of range)"; + case 105: return "integer overflow of bitsize"; + case 106: return "PNG file must have PLTE chunk if color type is palette"; + case 107: return "color convert from palette mode requested without setting the palette data in it"; + case 108: return "tried to add more than 256 values to a palette"; + /*this limit can be configured in LodePNGDecompressSettings*/ + case 109: return "tried to decompress zlib or deflate data larger than desired max_output_size"; + case 110: return "custom zlib or inflate decompression failed"; + case 111: return "custom zlib or deflate compression failed"; + /*max text size limit can be configured in LodePNGDecoderSettings. This error prevents + unreasonable memory consumption when decoding due to impossibly large text sizes.*/ + case 112: return "compressed text unreasonably large"; + /*max ICC size limit can be configured in LodePNGDecoderSettings. This error prevents + unreasonable memory consumption when decoding due to impossibly large ICC profile*/ + case 113: return "ICC profile unreasonably large"; + } + return "unknown error code"; +} +#endif /*LODEPNG_COMPILE_ERROR_TEXT*/ + +/* ////////////////////////////////////////////////////////////////////////// */ +/* ////////////////////////////////////////////////////////////////////////// */ +/* // C++ Wrapper // */ +/* ////////////////////////////////////////////////////////////////////////// */ +/* ////////////////////////////////////////////////////////////////////////// */ + +#ifdef LODEPNG_COMPILE_CPP +namespace lodepng { + +#ifdef LODEPNG_COMPILE_DISK +unsigned load_file(std::vector& buffer, const std::string& filename) { + long size = lodepng_filesize(filename.c_str()); + if(size < 0) return 78; + buffer.resize((size_t)size); + return size == 0 ? 0 : lodepng_buffer_file(&buffer[0], (size_t)size, filename.c_str()); +} + +/*write given buffer to the file, overwriting the file, it doesn't append to it.*/ +unsigned save_file(const std::vector& buffer, const std::string& filename) { + return lodepng_save_file(buffer.empty() ? 0 : &buffer[0], buffer.size(), filename.c_str()); +} +#endif /* LODEPNG_COMPILE_DISK */ + +#ifdef LODEPNG_COMPILE_ZLIB +#ifdef LODEPNG_COMPILE_DECODER +unsigned decompress(std::vector& out, const unsigned char* in, size_t insize, + const LodePNGDecompressSettings& settings) { + unsigned char* buffer = 0; + size_t buffersize = 0; + unsigned error = zlib_decompress(&buffer, &buffersize, 0, in, insize, &settings); + if(buffer) { + out.insert(out.end(), &buffer[0], &buffer[buffersize]); + lodepng_free(buffer); + } + return error; +} + +unsigned decompress(std::vector& out, const std::vector& in, + const LodePNGDecompressSettings& settings) { + return decompress(out, in.empty() ? 0 : &in[0], in.size(), settings); +} +#endif /* LODEPNG_COMPILE_DECODER */ + +#ifdef LODEPNG_COMPILE_ENCODER +unsigned compress(std::vector& out, const unsigned char* in, size_t insize, + const LodePNGCompressSettings& settings) { + unsigned char* buffer = 0; + size_t buffersize = 0; + unsigned error = zlib_compress(&buffer, &buffersize, in, insize, &settings); + if(buffer) { + out.insert(out.end(), &buffer[0], &buffer[buffersize]); + lodepng_free(buffer); + } + return error; +} + +unsigned compress(std::vector& out, const std::vector& in, + const LodePNGCompressSettings& settings) { + return compress(out, in.empty() ? 0 : &in[0], in.size(), settings); +} +#endif /* LODEPNG_COMPILE_ENCODER */ +#endif /* LODEPNG_COMPILE_ZLIB */ + + +#ifdef LODEPNG_COMPILE_PNG + +State::State() { + lodepng_state_init(this); +} + +State::State(const State& other) { + lodepng_state_init(this); + lodepng_state_copy(this, &other); +} + +State::~State() { + lodepng_state_cleanup(this); +} + +State& State::operator=(const State& other) { + lodepng_state_copy(this, &other); + return *this; +} + +#ifdef LODEPNG_COMPILE_DECODER + +unsigned decode(std::vector& out, unsigned& w, unsigned& h, const unsigned char* in, + size_t insize, LodePNGColorType colortype, unsigned bitdepth) { + unsigned char* buffer = 0; + unsigned error = lodepng_decode_memory(&buffer, &w, &h, in, insize, colortype, bitdepth); + if(buffer && !error) { + State state; + state.info_raw.colortype = colortype; + state.info_raw.bitdepth = bitdepth; + size_t buffersize = lodepng_get_raw_size(w, h, &state.info_raw); + out.insert(out.end(), &buffer[0], &buffer[buffersize]); + } + lodepng_free(buffer); + return error; +} + +unsigned decode(std::vector& out, unsigned& w, unsigned& h, + const std::vector& in, LodePNGColorType colortype, unsigned bitdepth) { + return decode(out, w, h, in.empty() ? 0 : &in[0], (unsigned)in.size(), colortype, bitdepth); +} + +unsigned decode(std::vector& out, unsigned& w, unsigned& h, + State& state, + const unsigned char* in, size_t insize) { + unsigned char* buffer = NULL; + unsigned error = lodepng_decode(&buffer, &w, &h, &state, in, insize); + if(buffer && !error) { + size_t buffersize = lodepng_get_raw_size(w, h, &state.info_raw); + out.insert(out.end(), &buffer[0], &buffer[buffersize]); + } + lodepng_free(buffer); + return error; +} + +unsigned decode(std::vector& out, unsigned& w, unsigned& h, + State& state, + const std::vector& in) { + return decode(out, w, h, state, in.empty() ? 0 : &in[0], in.size()); +} + +#ifdef LODEPNG_COMPILE_DISK +unsigned decode(std::vector& out, unsigned& w, unsigned& h, const std::string& filename, + LodePNGColorType colortype, unsigned bitdepth) { + std::vector buffer; + /* safe output values in case error happens */ + w = h = 0; + unsigned error = load_file(buffer, filename); + if(error) return error; + return decode(out, w, h, buffer, colortype, bitdepth); +} +#endif /* LODEPNG_COMPILE_DECODER */ +#endif /* LODEPNG_COMPILE_DISK */ + +#ifdef LODEPNG_COMPILE_ENCODER +unsigned encode(std::vector& out, const unsigned char* in, unsigned w, unsigned h, + LodePNGColorType colortype, unsigned bitdepth) { + unsigned char* buffer; + size_t buffersize; + unsigned error = lodepng_encode_memory(&buffer, &buffersize, in, w, h, colortype, bitdepth); + if(buffer) { + out.insert(out.end(), &buffer[0], &buffer[buffersize]); + lodepng_free(buffer); + } + return error; +} + +unsigned encode(std::vector& out, + const std::vector& in, unsigned w, unsigned h, + LodePNGColorType colortype, unsigned bitdepth) { + if(lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size()) return 84; + return encode(out, in.empty() ? 0 : &in[0], w, h, colortype, bitdepth); +} + +unsigned encode(std::vector& out, + const unsigned char* in, unsigned w, unsigned h, + State& state) { + unsigned char* buffer; + size_t buffersize; + unsigned error = lodepng_encode(&buffer, &buffersize, in, w, h, &state); + if(buffer) { + out.insert(out.end(), &buffer[0], &buffer[buffersize]); + lodepng_free(buffer); + } + return error; +} + +unsigned encode(std::vector& out, + const std::vector& in, unsigned w, unsigned h, + State& state) { + if(lodepng_get_raw_size(w, h, &state.info_raw) > in.size()) return 84; + return encode(out, in.empty() ? 0 : &in[0], w, h, state); +} + +#ifdef LODEPNG_COMPILE_DISK +unsigned encode(const std::string& filename, + const unsigned char* in, unsigned w, unsigned h, + LodePNGColorType colortype, unsigned bitdepth) { + std::vector buffer; + unsigned error = encode(buffer, in, w, h, colortype, bitdepth); + if(!error) error = save_file(buffer, filename); + return error; +} + +unsigned encode(const std::string& filename, + const std::vector& in, unsigned w, unsigned h, + LodePNGColorType colortype, unsigned bitdepth) { + if(lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size()) return 84; + return encode(filename, in.empty() ? 0 : &in[0], w, h, colortype, bitdepth); +} +#endif /* LODEPNG_COMPILE_DISK */ +#endif /* LODEPNG_COMPILE_ENCODER */ +#endif /* LODEPNG_COMPILE_PNG */ +} /* namespace lodepng */ +#endif /*LODEPNG_COMPILE_CPP*/ diff --git a/depends/lodepng/lodepng.h b/depends/lodepng/lodepng.h new file mode 100644 index 0000000000..6801cb789d --- /dev/null +++ b/depends/lodepng/lodepng.h @@ -0,0 +1,1977 @@ +/* +LodePNG version 20201017 + +Copyright (c) 2005-2020 Lode Vandevenne + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any damages +arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + + 3. This notice may not be removed or altered from any source + distribution. +*/ + +#ifndef LODEPNG_H +#define LODEPNG_H + +#include /*for size_t*/ + +extern const char* LODEPNG_VERSION_STRING; + +/* +The following #defines are used to create code sections. They can be disabled +to disable code sections, which can give faster compile time and smaller binary. +The "NO_COMPILE" defines are designed to be used to pass as defines to the +compiler command to disable them without modifying this header, e.g. +-DLODEPNG_NO_COMPILE_ZLIB for gcc. +In addition to those below, you can also define LODEPNG_NO_COMPILE_CRC to +allow implementing a custom lodepng_crc32. +*/ +/*deflate & zlib. If disabled, you must specify alternative zlib functions in +the custom_zlib field of the compress and decompress settings*/ +#ifndef LODEPNG_NO_COMPILE_ZLIB +#define LODEPNG_COMPILE_ZLIB +#endif + +/*png encoder and png decoder*/ +#ifndef LODEPNG_NO_COMPILE_PNG +#define LODEPNG_COMPILE_PNG +#endif + +/*deflate&zlib decoder and png decoder*/ +#ifndef LODEPNG_NO_COMPILE_DECODER +#define LODEPNG_COMPILE_DECODER +#endif + +/*deflate&zlib encoder and png encoder*/ +#ifndef LODEPNG_NO_COMPILE_ENCODER +#define LODEPNG_COMPILE_ENCODER +#endif + +/*the optional built in harddisk file loading and saving functions*/ +#ifndef LODEPNG_NO_COMPILE_DISK +#define LODEPNG_COMPILE_DISK +#endif + +/*support for chunks other than IHDR, IDAT, PLTE, tRNS, IEND: ancillary and unknown chunks*/ +#ifndef LODEPNG_NO_COMPILE_ANCILLARY_CHUNKS +#define LODEPNG_COMPILE_ANCILLARY_CHUNKS +#endif + +/*ability to convert error numerical codes to English text string*/ +#ifndef LODEPNG_NO_COMPILE_ERROR_TEXT +#define LODEPNG_COMPILE_ERROR_TEXT +#endif + +/*Compile the default allocators (C's free, malloc and realloc). If you disable this, +you can define the functions lodepng_free, lodepng_malloc and lodepng_realloc in your +source files with custom allocators.*/ +#ifndef LODEPNG_NO_COMPILE_ALLOCATORS +#define LODEPNG_COMPILE_ALLOCATORS +#endif + +/*compile the C++ version (you can disable the C++ wrapper here even when compiling for C++)*/ +#ifdef __cplusplus +#ifndef LODEPNG_NO_COMPILE_CPP +#define LODEPNG_COMPILE_CPP +#endif +#endif + +#ifdef LODEPNG_COMPILE_CPP +#include +#include +#endif /*LODEPNG_COMPILE_CPP*/ + +#ifdef LODEPNG_COMPILE_PNG +/*The PNG color types (also used for raw image).*/ +typedef enum LodePNGColorType { + LCT_GREY = 0, /*grayscale: 1,2,4,8,16 bit*/ + LCT_RGB = 2, /*RGB: 8,16 bit*/ + LCT_PALETTE = 3, /*palette: 1,2,4,8 bit*/ + LCT_GREY_ALPHA = 4, /*grayscale with alpha: 8,16 bit*/ + LCT_RGBA = 6, /*RGB with alpha: 8,16 bit*/ + /*LCT_MAX_OCTET_VALUE lets the compiler allow this enum to represent any invalid + byte value from 0 to 255 that could be present in an invalid PNG file header. Do + not use, compare with or set the name LCT_MAX_OCTET_VALUE, instead either use + the valid color type names above, or numeric values like 1 or 7 when checking for + particular disallowed color type byte values, or cast to integer to print it.*/ + LCT_MAX_OCTET_VALUE = 255 +} LodePNGColorType; + +#ifdef LODEPNG_COMPILE_DECODER +/* +Converts PNG data in memory to raw pixel data. +out: Output parameter. Pointer to buffer that will contain the raw pixel data. + After decoding, its size is w * h * (bytes per pixel) bytes larger than + initially. Bytes per pixel depends on colortype and bitdepth. + Must be freed after usage with free(*out). + Note: for 16-bit per channel colors, uses big endian format like PNG does. +w: Output parameter. Pointer to width of pixel data. +h: Output parameter. Pointer to height of pixel data. +in: Memory buffer with the PNG file. +insize: size of the in buffer. +colortype: the desired color type for the raw output image. See explanation on PNG color types. +bitdepth: the desired bit depth for the raw output image. See explanation on PNG color types. +Return value: LodePNG error code (0 means no error). +*/ +unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h, + const unsigned char* in, size_t insize, + LodePNGColorType colortype, unsigned bitdepth); + +/*Same as lodepng_decode_memory, but always decodes to 32-bit RGBA raw image*/ +unsigned lodepng_decode32(unsigned char** out, unsigned* w, unsigned* h, + const unsigned char* in, size_t insize); + +/*Same as lodepng_decode_memory, but always decodes to 24-bit RGB raw image*/ +unsigned lodepng_decode24(unsigned char** out, unsigned* w, unsigned* h, + const unsigned char* in, size_t insize); + +#ifdef LODEPNG_COMPILE_DISK +/* +Load PNG from disk, from file with given name. +Same as the other decode functions, but instead takes a filename as input. +*/ +unsigned lodepng_decode_file(unsigned char** out, unsigned* w, unsigned* h, + const char* filename, + LodePNGColorType colortype, unsigned bitdepth); + +/*Same as lodepng_decode_file, but always decodes to 32-bit RGBA raw image.*/ +unsigned lodepng_decode32_file(unsigned char** out, unsigned* w, unsigned* h, + const char* filename); + +/*Same as lodepng_decode_file, but always decodes to 24-bit RGB raw image.*/ +unsigned lodepng_decode24_file(unsigned char** out, unsigned* w, unsigned* h, + const char* filename); +#endif /*LODEPNG_COMPILE_DISK*/ +#endif /*LODEPNG_COMPILE_DECODER*/ + + +#ifdef LODEPNG_COMPILE_ENCODER +/* +Converts raw pixel data into a PNG image in memory. The colortype and bitdepth + of the output PNG image cannot be chosen, they are automatically determined + by the colortype, bitdepth and content of the input pixel data. + Note: for 16-bit per channel colors, needs big endian format like PNG does. +out: Output parameter. Pointer to buffer that will contain the PNG image data. + Must be freed after usage with free(*out). +outsize: Output parameter. Pointer to the size in bytes of the out buffer. +image: The raw pixel data to encode. The size of this buffer should be + w * h * (bytes per pixel), bytes per pixel depends on colortype and bitdepth. +w: width of the raw pixel data in pixels. +h: height of the raw pixel data in pixels. +colortype: the color type of the raw input image. See explanation on PNG color types. +bitdepth: the bit depth of the raw input image. See explanation on PNG color types. +Return value: LodePNG error code (0 means no error). +*/ +unsigned lodepng_encode_memory(unsigned char** out, size_t* outsize, + const unsigned char* image, unsigned w, unsigned h, + LodePNGColorType colortype, unsigned bitdepth); + +/*Same as lodepng_encode_memory, but always encodes from 32-bit RGBA raw image.*/ +unsigned lodepng_encode32(unsigned char** out, size_t* outsize, + const unsigned char* image, unsigned w, unsigned h); + +/*Same as lodepng_encode_memory, but always encodes from 24-bit RGB raw image.*/ +unsigned lodepng_encode24(unsigned char** out, size_t* outsize, + const unsigned char* image, unsigned w, unsigned h); + +#ifdef LODEPNG_COMPILE_DISK +/* +Converts raw pixel data into a PNG file on disk. +Same as the other encode functions, but instead takes a filename as output. +NOTE: This overwrites existing files without warning! +*/ +unsigned lodepng_encode_file(const char* filename, + const unsigned char* image, unsigned w, unsigned h, + LodePNGColorType colortype, unsigned bitdepth); + +/*Same as lodepng_encode_file, but always encodes from 32-bit RGBA raw image.*/ +unsigned lodepng_encode32_file(const char* filename, + const unsigned char* image, unsigned w, unsigned h); + +/*Same as lodepng_encode_file, but always encodes from 24-bit RGB raw image.*/ +unsigned lodepng_encode24_file(const char* filename, + const unsigned char* image, unsigned w, unsigned h); +#endif /*LODEPNG_COMPILE_DISK*/ +#endif /*LODEPNG_COMPILE_ENCODER*/ + + +#ifdef LODEPNG_COMPILE_CPP +namespace lodepng { +#ifdef LODEPNG_COMPILE_DECODER +/*Same as lodepng_decode_memory, but decodes to an std::vector. The colortype +is the format to output the pixels to. Default is RGBA 8-bit per channel.*/ +unsigned decode(std::vector& out, unsigned& w, unsigned& h, + const unsigned char* in, size_t insize, + LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8); +unsigned decode(std::vector& out, unsigned& w, unsigned& h, + const std::vector& in, + LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8); +#ifdef LODEPNG_COMPILE_DISK +/* +Converts PNG file from disk to raw pixel data in memory. +Same as the other decode functions, but instead takes a filename as input. +*/ +unsigned decode(std::vector& out, unsigned& w, unsigned& h, + const std::string& filename, + LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8); +#endif /* LODEPNG_COMPILE_DISK */ +#endif /* LODEPNG_COMPILE_DECODER */ + +#ifdef LODEPNG_COMPILE_ENCODER +/*Same as lodepng_encode_memory, but encodes to an std::vector. colortype +is that of the raw input data. The output PNG color type will be auto chosen.*/ +unsigned encode(std::vector& out, + const unsigned char* in, unsigned w, unsigned h, + LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8); +unsigned encode(std::vector& out, + const std::vector& in, unsigned w, unsigned h, + LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8); +#ifdef LODEPNG_COMPILE_DISK +/* +Converts 32-bit RGBA raw pixel data into a PNG file on disk. +Same as the other encode functions, but instead takes a filename as output. +NOTE: This overwrites existing files without warning! +*/ +unsigned encode(const std::string& filename, + const unsigned char* in, unsigned w, unsigned h, + LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8); +unsigned encode(const std::string& filename, + const std::vector& in, unsigned w, unsigned h, + LodePNGColorType colortype = LCT_RGBA, unsigned bitdepth = 8); +#endif /* LODEPNG_COMPILE_DISK */ +#endif /* LODEPNG_COMPILE_ENCODER */ +} /* namespace lodepng */ +#endif /*LODEPNG_COMPILE_CPP*/ +#endif /*LODEPNG_COMPILE_PNG*/ + +#ifdef LODEPNG_COMPILE_ERROR_TEXT +/*Returns an English description of the numerical error code.*/ +const char* lodepng_error_text(unsigned code); +#endif /*LODEPNG_COMPILE_ERROR_TEXT*/ + +#ifdef LODEPNG_COMPILE_DECODER +/*Settings for zlib decompression*/ +typedef struct LodePNGDecompressSettings LodePNGDecompressSettings; +struct LodePNGDecompressSettings { + /* Check LodePNGDecoderSettings for more ignorable errors such as ignore_crc */ + unsigned ignore_adler32; /*if 1, continue and don't give an error message if the Adler32 checksum is corrupted*/ + unsigned ignore_nlen; /*ignore complement of len checksum in uncompressed blocks*/ + + /*Maximum decompressed size, beyond this the decoder may (and is encouraged to) stop decoding, + return an error, output a data size > max_output_size and all the data up to that point. This is + not hard limit nor a guarantee, but can prevent excessive memory usage. This setting is + ignored by the PNG decoder, but is used by the deflate/zlib decoder and can be used by custom ones. + Set to 0 to impose no limit (the default).*/ + size_t max_output_size; + + /*use custom zlib decoder instead of built in one (default: null). + Should return 0 if success, any non-0 if error (numeric value not exposed).*/ + unsigned (*custom_zlib)(unsigned char**, size_t*, + const unsigned char*, size_t, + const LodePNGDecompressSettings*); + /*use custom deflate decoder instead of built in one (default: null) + if custom_zlib is not null, custom_inflate is ignored (the zlib format uses deflate). + Should return 0 if success, any non-0 if error (numeric value not exposed).*/ + unsigned (*custom_inflate)(unsigned char**, size_t*, + const unsigned char*, size_t, + const LodePNGDecompressSettings*); + + const void* custom_context; /*optional custom settings for custom functions*/ +}; + +extern const LodePNGDecompressSettings lodepng_default_decompress_settings; +void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings); +#endif /*LODEPNG_COMPILE_DECODER*/ + +#ifdef LODEPNG_COMPILE_ENCODER +/* +Settings for zlib compression. Tweaking these settings tweaks the balance +between speed and compression ratio. +*/ +typedef struct LodePNGCompressSettings LodePNGCompressSettings; +struct LodePNGCompressSettings /*deflate = compress*/ { + /*LZ77 related settings*/ + unsigned btype; /*the block type for LZ (0, 1, 2 or 3, see zlib standard). Should be 2 for proper compression.*/ + unsigned use_lz77; /*whether or not to use LZ77. Should be 1 for proper compression.*/ + unsigned windowsize; /*must be a power of two <= 32768. higher compresses more but is slower. Default value: 2048.*/ + unsigned minmatch; /*minimum lz77 length. 3 is normally best, 6 can be better for some PNGs. Default: 0*/ + unsigned nicematch; /*stop searching if >= this length found. Set to 258 for best compression. Default: 128*/ + unsigned lazymatching; /*use lazy matching: better compression but a bit slower. Default: true*/ + + /*use custom zlib encoder instead of built in one (default: null)*/ + unsigned (*custom_zlib)(unsigned char**, size_t*, + const unsigned char*, size_t, + const LodePNGCompressSettings*); + /*use custom deflate encoder instead of built in one (default: null) + if custom_zlib is used, custom_deflate is ignored since only the built in + zlib function will call custom_deflate*/ + unsigned (*custom_deflate)(unsigned char**, size_t*, + const unsigned char*, size_t, + const LodePNGCompressSettings*); + + const void* custom_context; /*optional custom settings for custom functions*/ +}; + +extern const LodePNGCompressSettings lodepng_default_compress_settings; +void lodepng_compress_settings_init(LodePNGCompressSettings* settings); +#endif /*LODEPNG_COMPILE_ENCODER*/ + +#ifdef LODEPNG_COMPILE_PNG +/* +Color mode of an image. Contains all information required to decode the pixel +bits to RGBA colors. This information is the same as used in the PNG file +format, and is used both for PNG and raw image data in LodePNG. +*/ +typedef struct LodePNGColorMode { + /*header (IHDR)*/ + LodePNGColorType colortype; /*color type, see PNG standard or documentation further in this header file*/ + unsigned bitdepth; /*bits per sample, see PNG standard or documentation further in this header file*/ + + /* + palette (PLTE and tRNS) + + Dynamically allocated with the colors of the palette, including alpha. + This field may not be allocated directly, use lodepng_color_mode_init first, + then lodepng_palette_add per color to correctly initialize it (to ensure size + of exactly 1024 bytes). + + The alpha channels must be set as well, set them to 255 for opaque images. + + When decoding, by default you can ignore this palette, since LodePNG already + fills the palette colors in the pixels of the raw RGBA output. + + The palette is only supported for color type 3. + */ + unsigned char* palette; /*palette in RGBARGBA... order. Must be either 0, or when allocated must have 1024 bytes*/ + size_t palettesize; /*palette size in number of colors (amount of used bytes is 4 * palettesize)*/ + + /* + transparent color key (tRNS) + + This color uses the same bit depth as the bitdepth value in this struct, which can be 1-bit to 16-bit. + For grayscale PNGs, r, g and b will all 3 be set to the same. + + When decoding, by default you can ignore this information, since LodePNG sets + pixels with this key to transparent already in the raw RGBA output. + + The color key is only supported for color types 0 and 2. + */ + unsigned key_defined; /*is a transparent color key given? 0 = false, 1 = true*/ + unsigned key_r; /*red/grayscale component of color key*/ + unsigned key_g; /*green component of color key*/ + unsigned key_b; /*blue component of color key*/ +} LodePNGColorMode; + +/*init, cleanup and copy functions to use with this struct*/ +void lodepng_color_mode_init(LodePNGColorMode* info); +void lodepng_color_mode_cleanup(LodePNGColorMode* info); +/*return value is error code (0 means no error)*/ +unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source); +/* Makes a temporary LodePNGColorMode that does not need cleanup (no palette) */ +LodePNGColorMode lodepng_color_mode_make(LodePNGColorType colortype, unsigned bitdepth); + +void lodepng_palette_clear(LodePNGColorMode* info); +/*add 1 color to the palette*/ +unsigned lodepng_palette_add(LodePNGColorMode* info, + unsigned char r, unsigned char g, unsigned char b, unsigned char a); + +/*get the total amount of bits per pixel, based on colortype and bitdepth in the struct*/ +unsigned lodepng_get_bpp(const LodePNGColorMode* info); +/*get the amount of color channels used, based on colortype in the struct. +If a palette is used, it counts as 1 channel.*/ +unsigned lodepng_get_channels(const LodePNGColorMode* info); +/*is it a grayscale type? (only colortype 0 or 4)*/ +unsigned lodepng_is_greyscale_type(const LodePNGColorMode* info); +/*has it got an alpha channel? (only colortype 2 or 6)*/ +unsigned lodepng_is_alpha_type(const LodePNGColorMode* info); +/*has it got a palette? (only colortype 3)*/ +unsigned lodepng_is_palette_type(const LodePNGColorMode* info); +/*only returns true if there is a palette and there is a value in the palette with alpha < 255. +Loops through the palette to check this.*/ +unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info); +/* +Check if the given color info indicates the possibility of having non-opaque pixels in the PNG image. +Returns true if the image can have translucent or invisible pixels (it still be opaque if it doesn't use such pixels). +Returns false if the image can only have opaque pixels. +In detail, it returns true only if it's a color type with alpha, or has a palette with non-opaque values, +or if "key_defined" is true. +*/ +unsigned lodepng_can_have_alpha(const LodePNGColorMode* info); +/*Returns the byte size of a raw image buffer with given width, height and color mode*/ +size_t lodepng_get_raw_size(unsigned w, unsigned h, const LodePNGColorMode* color); + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS +/*The information of a Time chunk in PNG.*/ +typedef struct LodePNGTime { + unsigned year; /*2 bytes used (0-65535)*/ + unsigned month; /*1-12*/ + unsigned day; /*1-31*/ + unsigned hour; /*0-23*/ + unsigned minute; /*0-59*/ + unsigned second; /*0-60 (to allow for leap seconds)*/ +} LodePNGTime; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + +/*Information about the PNG image, except pixels, width and height.*/ +typedef struct LodePNGInfo { + /*header (IHDR), palette (PLTE) and transparency (tRNS) chunks*/ + unsigned compression_method;/*compression method of the original file. Always 0.*/ + unsigned filter_method; /*filter method of the original file*/ + unsigned interlace_method; /*interlace method of the original file: 0=none, 1=Adam7*/ + LodePNGColorMode color; /*color type and bits, palette and transparency of the PNG file*/ + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + /* + Suggested background color chunk (bKGD) + + This uses the same color mode and bit depth as the PNG (except no alpha channel), + with values truncated to the bit depth in the unsigned integer. + + For grayscale and palette PNGs, the value is stored in background_r. The values + in background_g and background_b are then unused. + + So when decoding, you may get these in a different color mode than the one you requested + for the raw pixels. + + When encoding with auto_convert, you must use the color model defined in info_png.color for + these values. The encoder normally ignores info_png.color when auto_convert is on, but will + use it to interpret these values (and convert copies of them to its chosen color model). + + When encoding, avoid setting this to an expensive color, such as a non-gray value + when the image is gray, or the compression will be worse since it will be forced to + write the PNG with a more expensive color mode (when auto_convert is on). + + The decoder does not use this background color to edit the color of pixels. This is a + completely optional metadata feature. + */ + unsigned background_defined; /*is a suggested background color given?*/ + unsigned background_r; /*red/gray/palette component of suggested background color*/ + unsigned background_g; /*green component of suggested background color*/ + unsigned background_b; /*blue component of suggested background color*/ + + /* + Non-international text chunks (tEXt and zTXt) + + The char** arrays each contain num strings. The actual messages are in + text_strings, while text_keys are keywords that give a short description what + the actual text represents, e.g. Title, Author, Description, or anything else. + + All the string fields below including strings, keys, names and language tags are null terminated. + The PNG specification uses null characters for the keys, names and tags, and forbids null + characters to appear in the main text which is why we can use null termination everywhere here. + + A keyword is minimum 1 character and maximum 79 characters long (plus the + additional null terminator). It's discouraged to use a single line length + longer than 79 characters for texts. + + Don't allocate these text buffers yourself. Use the init/cleanup functions + correctly and use lodepng_add_text and lodepng_clear_text. + + Standard text chunk keywords and strings are encoded using Latin-1. + */ + size_t text_num; /*the amount of texts in these char** buffers (there may be more texts in itext)*/ + char** text_keys; /*the keyword of a text chunk (e.g. "Comment")*/ + char** text_strings; /*the actual text*/ + + /* + International text chunks (iTXt) + Similar to the non-international text chunks, but with additional strings + "langtags" and "transkeys", and the following text encodings are used: + keys: Latin-1, langtags: ASCII, transkeys and strings: UTF-8. + keys must be 1-79 characters (plus the additional null terminator), the other + strings are any length. + */ + size_t itext_num; /*the amount of international texts in this PNG*/ + char** itext_keys; /*the English keyword of the text chunk (e.g. "Comment")*/ + char** itext_langtags; /*language tag for this text's language, ISO/IEC 646 string, e.g. ISO 639 language tag*/ + char** itext_transkeys; /*keyword translated to the international language - UTF-8 string*/ + char** itext_strings; /*the actual international text - UTF-8 string*/ + + /*time chunk (tIME)*/ + unsigned time_defined; /*set to 1 to make the encoder generate a tIME chunk*/ + LodePNGTime time; + + /*phys chunk (pHYs)*/ + unsigned phys_defined; /*if 0, there is no pHYs chunk and the values below are undefined, if 1 else there is one*/ + unsigned phys_x; /*pixels per unit in x direction*/ + unsigned phys_y; /*pixels per unit in y direction*/ + unsigned phys_unit; /*may be 0 (unknown unit) or 1 (metre)*/ + + /* + Color profile related chunks: gAMA, cHRM, sRGB, iCPP + + LodePNG does not apply any color conversions on pixels in the encoder or decoder and does not interpret these color + profile values. It merely passes on the information. If you wish to use color profiles and convert colors, please + use these values with a color management library. + + See the PNG, ICC and sRGB specifications for more information about the meaning of these values. + */ + + /* gAMA chunk: optional, overridden by sRGB or iCCP if those are present. */ + unsigned gama_defined; /* Whether a gAMA chunk is present (0 = not present, 1 = present). */ + unsigned gama_gamma; /* Gamma exponent times 100000 */ + + /* cHRM chunk: optional, overridden by sRGB or iCCP if those are present. */ + unsigned chrm_defined; /* Whether a cHRM chunk is present (0 = not present, 1 = present). */ + unsigned chrm_white_x; /* White Point x times 100000 */ + unsigned chrm_white_y; /* White Point y times 100000 */ + unsigned chrm_red_x; /* Red x times 100000 */ + unsigned chrm_red_y; /* Red y times 100000 */ + unsigned chrm_green_x; /* Green x times 100000 */ + unsigned chrm_green_y; /* Green y times 100000 */ + unsigned chrm_blue_x; /* Blue x times 100000 */ + unsigned chrm_blue_y; /* Blue y times 100000 */ + + /* + sRGB chunk: optional. May not appear at the same time as iCCP. + If gAMA is also present gAMA must contain value 45455. + If cHRM is also present cHRM must contain respectively 31270,32900,64000,33000,30000,60000,15000,6000. + */ + unsigned srgb_defined; /* Whether an sRGB chunk is present (0 = not present, 1 = present). */ + unsigned srgb_intent; /* Rendering intent: 0=perceptual, 1=rel. colorimetric, 2=saturation, 3=abs. colorimetric */ + + /* + iCCP chunk: optional. May not appear at the same time as sRGB. + + LodePNG does not parse or use the ICC profile (except its color space header field for an edge case), a + separate library to handle the ICC data (not included in LodePNG) format is needed to use it for color + management and conversions. + + For encoding, if iCCP is present, gAMA and cHRM are recommended to be added as well with values that match the ICC + profile as closely as possible, if you wish to do this you should provide the correct values for gAMA and cHRM and + enable their '_defined' flags since LodePNG will not automatically compute them from the ICC profile. + + For encoding, the ICC profile is required by the PNG specification to be an "RGB" profile for non-gray + PNG color types and a "GRAY" profile for gray PNG color types. If you disable auto_convert, you must ensure + the ICC profile type matches your requested color type, else the encoder gives an error. If auto_convert is + enabled (the default), and the ICC profile is not a good match for the pixel data, this will result in an encoder + error if the pixel data has non-gray pixels for a GRAY profile, or a silent less-optimal compression of the pixel + data if the pixels could be encoded as grayscale but the ICC profile is RGB. + + To avoid this do not set an ICC profile in the image unless there is a good reason for it, and when doing so + make sure you compute it carefully to avoid the above problems. + */ + unsigned iccp_defined; /* Whether an iCCP chunk is present (0 = not present, 1 = present). */ + char* iccp_name; /* Null terminated string with profile name, 1-79 bytes */ + /* + The ICC profile in iccp_profile_size bytes. + Don't allocate this buffer yourself. Use the init/cleanup functions + correctly and use lodepng_set_icc and lodepng_clear_icc. + */ + unsigned char* iccp_profile; + unsigned iccp_profile_size; /* The size of iccp_profile in bytes */ + + /* End of color profile related chunks */ + + + /* + unknown chunks: chunks not known by LodePNG, passed on byte for byte. + + There are 3 buffers, one for each position in the PNG where unknown chunks can appear. + Each buffer contains all unknown chunks for that position consecutively. + The 3 positions are: + 0: between IHDR and PLTE, 1: between PLTE and IDAT, 2: between IDAT and IEND. + + For encoding, do not store critical chunks or known chunks that are enabled with a "_defined" flag + above in here, since the encoder will blindly follow this and could then encode an invalid PNG file + (such as one with two IHDR chunks or the disallowed combination of sRGB with iCCP). But do use + this if you wish to store an ancillary chunk that is not supported by LodePNG (such as sPLT or hIST), + or any non-standard PNG chunk. + + Do not allocate or traverse this data yourself. Use the chunk traversing functions declared + later, such as lodepng_chunk_next and lodepng_chunk_append, to read/write this struct. + */ + unsigned char* unknown_chunks_data[3]; + size_t unknown_chunks_size[3]; /*size in bytes of the unknown chunks, given for protection*/ +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ +} LodePNGInfo; + +/*init, cleanup and copy functions to use with this struct*/ +void lodepng_info_init(LodePNGInfo* info); +void lodepng_info_cleanup(LodePNGInfo* info); +/*return value is error code (0 means no error)*/ +unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source); + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS +unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str); /*push back both texts at once*/ +void lodepng_clear_text(LodePNGInfo* info); /*use this to clear the texts again after you filled them in*/ + +unsigned lodepng_add_itext(LodePNGInfo* info, const char* key, const char* langtag, + const char* transkey, const char* str); /*push back the 4 texts of 1 chunk at once*/ +void lodepng_clear_itext(LodePNGInfo* info); /*use this to clear the itexts again after you filled them in*/ + +/*replaces if exists*/ +unsigned lodepng_set_icc(LodePNGInfo* info, const char* name, const unsigned char* profile, unsigned profile_size); +void lodepng_clear_icc(LodePNGInfo* info); /*use this to clear the texts again after you filled them in*/ +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ + +/* +Converts raw buffer from one color type to another color type, based on +LodePNGColorMode structs to describe the input and output color type. +See the reference manual at the end of this header file to see which color conversions are supported. +return value = LodePNG error code (0 if all went ok, an error if the conversion isn't supported) +The out buffer must have size (w * h * bpp + 7) / 8, where bpp is the bits per pixel +of the output color type (lodepng_get_bpp). +For < 8 bpp images, there should not be padding bits at the end of scanlines. +For 16-bit per channel colors, uses big endian format like PNG does. +Return value is LodePNG error code +*/ +unsigned lodepng_convert(unsigned char* out, const unsigned char* in, + const LodePNGColorMode* mode_out, const LodePNGColorMode* mode_in, + unsigned w, unsigned h); + +#ifdef LODEPNG_COMPILE_DECODER +/* +Settings for the decoder. This contains settings for the PNG and the Zlib +decoder, but not the Info settings from the Info structs. +*/ +typedef struct LodePNGDecoderSettings { + LodePNGDecompressSettings zlibsettings; /*in here is the setting to ignore Adler32 checksums*/ + + /* Check LodePNGDecompressSettings for more ignorable errors such as ignore_adler32 */ + unsigned ignore_crc; /*ignore CRC checksums*/ + unsigned ignore_critical; /*ignore unknown critical chunks*/ + unsigned ignore_end; /*ignore issues at end of file if possible (missing IEND chunk, too large chunk, ...)*/ + /* TODO: make a system involving warnings with levels and a strict mode instead. Other potentially recoverable + errors: srgb rendering intent value, size of content of ancillary chunks, more than 79 characters for some + strings, placement/combination rules for ancillary chunks, crc of unknown chunks, allowed characters + in string keys, etc... */ + + unsigned color_convert; /*whether to convert the PNG to the color type you want. Default: yes*/ + +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + unsigned read_text_chunks; /*if false but remember_unknown_chunks is true, they're stored in the unknown chunks*/ + + /*store all bytes from unknown chunks in the LodePNGInfo (off by default, useful for a png editor)*/ + unsigned remember_unknown_chunks; + + /* maximum size for decompressed text chunks. If a text chunk's text is larger than this, an error is returned, + unless reading text chunks is disabled or this limit is set higher or disabled. Set to 0 to allow any size. + By default it is a value that prevents unreasonably large strings from hogging memory. */ + size_t max_text_size; + + /* maximum size for compressed ICC chunks. If the ICC profile is larger than this, an error will be returned. Set to + 0 to allow any size. By default this is a value that prevents ICC profiles that would be much larger than any + legitimate profile could be to hog memory. */ + size_t max_icc_size; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ +} LodePNGDecoderSettings; + +void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings); +#endif /*LODEPNG_COMPILE_DECODER*/ + +#ifdef LODEPNG_COMPILE_ENCODER +/*automatically use color type with less bits per pixel if losslessly possible. Default: AUTO*/ +typedef enum LodePNGFilterStrategy { + /*every filter at zero*/ + LFS_ZERO = 0, + /*every filter at 1, 2, 3 or 4 (paeth), unlike LFS_ZERO not a good choice, but for testing*/ + LFS_ONE = 1, + LFS_TWO = 2, + LFS_THREE = 3, + LFS_FOUR = 4, + /*Use filter that gives minimum sum, as described in the official PNG filter heuristic.*/ + LFS_MINSUM, + /*Use the filter type that gives smallest Shannon entropy for this scanline. Depending + on the image, this is better or worse than minsum.*/ + LFS_ENTROPY, + /* + Brute-force-search PNG filters by compressing each filter for each scanline. + Experimental, very slow, and only rarely gives better compression than MINSUM. + */ + LFS_BRUTE_FORCE, + /*use predefined_filters buffer: you specify the filter type for each scanline*/ + LFS_PREDEFINED +} LodePNGFilterStrategy; + +/*Gives characteristics about the integer RGBA colors of the image (count, alpha channel usage, bit depth, ...), +which helps decide which color model to use for encoding. +Used internally by default if "auto_convert" is enabled. Public because it's useful for custom algorithms.*/ +typedef struct LodePNGColorStats { + unsigned colored; /*not grayscale*/ + unsigned key; /*image is not opaque and color key is possible instead of full alpha*/ + unsigned short key_r; /*key values, always as 16-bit, in 8-bit case the byte is duplicated, e.g. 65535 means 255*/ + unsigned short key_g; + unsigned short key_b; + unsigned alpha; /*image is not opaque and alpha channel or alpha palette required*/ + unsigned numcolors; /*amount of colors, up to 257. Not valid if bits == 16 or allow_palette is disabled.*/ + unsigned char palette[1024]; /*Remembers up to the first 256 RGBA colors, in no particular order, only valid when numcolors is valid*/ + unsigned bits; /*bits per channel (not for palette). 1,2 or 4 for grayscale only. 16 if 16-bit per channel required.*/ + size_t numpixels; + + /*user settings for computing/using the stats*/ + unsigned allow_palette; /*default 1. if 0, disallow choosing palette colortype in auto_choose_color, and don't count numcolors*/ + unsigned allow_greyscale; /*default 1. if 0, choose RGB or RGBA even if the image only has gray colors*/ +} LodePNGColorStats; + +void lodepng_color_stats_init(LodePNGColorStats* stats); + +/*Get a LodePNGColorStats of the image. The stats must already have been inited. +Returns error code (e.g. alloc fail) or 0 if ok.*/ +unsigned lodepng_compute_color_stats(LodePNGColorStats* stats, + const unsigned char* image, unsigned w, unsigned h, + const LodePNGColorMode* mode_in); + +/*Settings for the encoder.*/ +typedef struct LodePNGEncoderSettings { + LodePNGCompressSettings zlibsettings; /*settings for the zlib encoder, such as window size, ...*/ + + unsigned auto_convert; /*automatically choose output PNG color type. Default: true*/ + + /*If true, follows the official PNG heuristic: if the PNG uses a palette or lower than + 8 bit depth, set all filters to zero. Otherwise use the filter_strategy. Note that to + completely follow the official PNG heuristic, filter_palette_zero must be true and + filter_strategy must be LFS_MINSUM*/ + unsigned filter_palette_zero; + /*Which filter strategy to use when not using zeroes due to filter_palette_zero. + Set filter_palette_zero to 0 to ensure always using your chosen strategy. Default: LFS_MINSUM*/ + LodePNGFilterStrategy filter_strategy; + /*used if filter_strategy is LFS_PREDEFINED. In that case, this must point to a buffer with + the same length as the amount of scanlines in the image, and each value must <= 5. You + have to cleanup this buffer, LodePNG will never free it. Don't forget that filter_palette_zero + must be set to 0 to ensure this is also used on palette or low bitdepth images.*/ + const unsigned char* predefined_filters; + + /*force creating a PLTE chunk if colortype is 2 or 6 (= a suggested palette). + If colortype is 3, PLTE is _always_ created.*/ + unsigned force_palette; +#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS + /*add LodePNG identifier and version as a text chunk, for debugging*/ + unsigned add_id; + /*encode text chunks as zTXt chunks instead of tEXt chunks, and use compression in iTXt chunks*/ + unsigned text_compression; +#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/ +} LodePNGEncoderSettings; + +void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings); +#endif /*LODEPNG_COMPILE_ENCODER*/ + + +#if defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER) +/*The settings, state and information for extended encoding and decoding.*/ +typedef struct LodePNGState { +#ifdef LODEPNG_COMPILE_DECODER + LodePNGDecoderSettings decoder; /*the decoding settings*/ +#endif /*LODEPNG_COMPILE_DECODER*/ +#ifdef LODEPNG_COMPILE_ENCODER + LodePNGEncoderSettings encoder; /*the encoding settings*/ +#endif /*LODEPNG_COMPILE_ENCODER*/ + LodePNGColorMode info_raw; /*specifies the format in which you would like to get the raw pixel buffer*/ + LodePNGInfo info_png; /*info of the PNG image obtained after decoding*/ + unsigned error; +} LodePNGState; + +/*init, cleanup and copy functions to use with this struct*/ +void lodepng_state_init(LodePNGState* state); +void lodepng_state_cleanup(LodePNGState* state); +void lodepng_state_copy(LodePNGState* dest, const LodePNGState* source); +#endif /* defined(LODEPNG_COMPILE_DECODER) || defined(LODEPNG_COMPILE_ENCODER) */ + +#ifdef LODEPNG_COMPILE_DECODER +/* +Same as lodepng_decode_memory, but uses a LodePNGState to allow custom settings and +getting much more information about the PNG image and color mode. +*/ +unsigned lodepng_decode(unsigned char** out, unsigned* w, unsigned* h, + LodePNGState* state, + const unsigned char* in, size_t insize); + +/* +Read the PNG header, but not the actual data. This returns only the information +that is in the IHDR chunk of the PNG, such as width, height and color type. The +information is placed in the info_png field of the LodePNGState. +*/ +unsigned lodepng_inspect(unsigned* w, unsigned* h, + LodePNGState* state, + const unsigned char* in, size_t insize); +#endif /*LODEPNG_COMPILE_DECODER*/ + +/* +Reads one metadata chunk (other than IHDR) of the PNG file and outputs what it +read in the state. Returns error code on failure. +Use lodepng_inspect first with a new state, then e.g. lodepng_chunk_find_const +to find the desired chunk type, and if non null use lodepng_inspect_chunk (with +chunk_pointer - start_of_file as pos). +Supports most metadata chunks from the PNG standard (gAMA, bKGD, tEXt, ...). +Ignores unsupported, unknown, non-metadata or IHDR chunks (without error). +Requirements: &in[pos] must point to start of a chunk, must use regular +lodepng_inspect first since format of most other chunks depends on IHDR, and if +there is a PLTE chunk, that one must be inspected before tRNS or bKGD. +*/ +unsigned lodepng_inspect_chunk(LodePNGState* state, size_t pos, + const unsigned char* in, size_t insize); + +#ifdef LODEPNG_COMPILE_ENCODER +/*This function allocates the out buffer with standard malloc and stores the size in *outsize.*/ +unsigned lodepng_encode(unsigned char** out, size_t* outsize, + const unsigned char* image, unsigned w, unsigned h, + LodePNGState* state); +#endif /*LODEPNG_COMPILE_ENCODER*/ + +/* +The lodepng_chunk functions are normally not needed, except to traverse the +unknown chunks stored in the LodePNGInfo struct, or add new ones to it. +It also allows traversing the chunks of an encoded PNG file yourself. + +The chunk pointer always points to the beginning of the chunk itself, that is +the first byte of the 4 length bytes. + +In the PNG file format, chunks have the following format: +-4 bytes length: length of the data of the chunk in bytes (chunk itself is 12 bytes longer) +-4 bytes chunk type (ASCII a-z,A-Z only, see below) +-length bytes of data (may be 0 bytes if length was 0) +-4 bytes of CRC, computed on chunk name + data + +The first chunk starts at the 8th byte of the PNG file, the entire rest of the file +exists out of concatenated chunks with the above format. + +PNG standard chunk ASCII naming conventions: +-First byte: uppercase = critical, lowercase = ancillary +-Second byte: uppercase = public, lowercase = private +-Third byte: must be uppercase +-Fourth byte: uppercase = unsafe to copy, lowercase = safe to copy +*/ + +/* +Gets the length of the data of the chunk. Total chunk length has 12 bytes more. +There must be at least 4 bytes to read from. If the result value is too large, +it may be corrupt data. +*/ +unsigned lodepng_chunk_length(const unsigned char* chunk); + +/*puts the 4-byte type in null terminated string*/ +void lodepng_chunk_type(char type[5], const unsigned char* chunk); + +/*check if the type is the given type*/ +unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type); + +/*0: it's one of the critical chunk types, 1: it's an ancillary chunk (see PNG standard)*/ +unsigned char lodepng_chunk_ancillary(const unsigned char* chunk); + +/*0: public, 1: private (see PNG standard)*/ +unsigned char lodepng_chunk_private(const unsigned char* chunk); + +/*0: the chunk is unsafe to copy, 1: the chunk is safe to copy (see PNG standard)*/ +unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk); + +/*get pointer to the data of the chunk, where the input points to the header of the chunk*/ +unsigned char* lodepng_chunk_data(unsigned char* chunk); +const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk); + +/*returns 0 if the crc is correct, 1 if it's incorrect (0 for OK as usual!)*/ +unsigned lodepng_chunk_check_crc(const unsigned char* chunk); + +/*generates the correct CRC from the data and puts it in the last 4 bytes of the chunk*/ +void lodepng_chunk_generate_crc(unsigned char* chunk); + +/* +Iterate to next chunks, allows iterating through all chunks of the PNG file. +Input must be at the beginning of a chunk (result of a previous lodepng_chunk_next call, +or the 8th byte of a PNG file which always has the first chunk), or alternatively may +point to the first byte of the PNG file (which is not a chunk but the magic header, the +function will then skip over it and return the first real chunk). +Will output pointer to the start of the next chunk, or at or beyond end of the file if there +is no more chunk after this or possibly if the chunk is corrupt. +Start this process at the 8th byte of the PNG file. +In a non-corrupt PNG file, the last chunk should have name "IEND". +*/ +unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end); +const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end); + +/*Finds the first chunk with the given type in the range [chunk, end), or returns NULL if not found.*/ +unsigned char* lodepng_chunk_find(unsigned char* chunk, unsigned char* end, const char type[5]); +const unsigned char* lodepng_chunk_find_const(const unsigned char* chunk, const unsigned char* end, const char type[5]); + +/* +Appends chunk to the data in out. The given chunk should already have its chunk header. +The out variable and outsize are updated to reflect the new reallocated buffer. +Returns error code (0 if it went ok) +*/ +unsigned lodepng_chunk_append(unsigned char** out, size_t* outsize, const unsigned char* chunk); + +/* +Appends new chunk to out. The chunk to append is given by giving its length, type +and data separately. The type is a 4-letter string. +The out variable and outsize are updated to reflect the new reallocated buffer. +Returne error code (0 if it went ok) +*/ +unsigned lodepng_chunk_create(unsigned char** out, size_t* outsize, unsigned length, + const char* type, const unsigned char* data); + + +/*Calculate CRC32 of buffer*/ +unsigned lodepng_crc32(const unsigned char* buf, size_t len); +#endif /*LODEPNG_COMPILE_PNG*/ + + +#ifdef LODEPNG_COMPILE_ZLIB +/* +This zlib part can be used independently to zlib compress and decompress a +buffer. It cannot be used to create gzip files however, and it only supports the +part of zlib that is required for PNG, it does not support dictionaries. +*/ + +#ifdef LODEPNG_COMPILE_DECODER +/*Inflate a buffer. Inflate is the decompression step of deflate. Out buffer must be freed after use.*/ +unsigned lodepng_inflate(unsigned char** out, size_t* outsize, + const unsigned char* in, size_t insize, + const LodePNGDecompressSettings* settings); + +/* +Decompresses Zlib data. Reallocates the out buffer and appends the data. The +data must be according to the zlib specification. +Either, *out must be NULL and *outsize must be 0, or, *out must be a valid +buffer and *outsize its size in bytes. out must be freed by user after usage. +*/ +unsigned lodepng_zlib_decompress(unsigned char** out, size_t* outsize, + const unsigned char* in, size_t insize, + const LodePNGDecompressSettings* settings); +#endif /*LODEPNG_COMPILE_DECODER*/ + +#ifdef LODEPNG_COMPILE_ENCODER +/* +Compresses data with Zlib. Reallocates the out buffer and appends the data. +Zlib adds a small header and trailer around the deflate data. +The data is output in the format of the zlib specification. +Either, *out must be NULL and *outsize must be 0, or, *out must be a valid +buffer and *outsize its size in bytes. out must be freed by user after usage. +*/ +unsigned lodepng_zlib_compress(unsigned char** out, size_t* outsize, + const unsigned char* in, size_t insize, + const LodePNGCompressSettings* settings); + +/* +Find length-limited Huffman code for given frequencies. This function is in the +public interface only for tests, it's used internally by lodepng_deflate. +*/ +unsigned lodepng_huffman_code_lengths(unsigned* lengths, const unsigned* frequencies, + size_t numcodes, unsigned maxbitlen); + +/*Compress a buffer with deflate. See RFC 1951. Out buffer must be freed after use.*/ +unsigned lodepng_deflate(unsigned char** out, size_t* outsize, + const unsigned char* in, size_t insize, + const LodePNGCompressSettings* settings); + +#endif /*LODEPNG_COMPILE_ENCODER*/ +#endif /*LODEPNG_COMPILE_ZLIB*/ + +#ifdef LODEPNG_COMPILE_DISK +/* +Load a file from disk into buffer. The function allocates the out buffer, and +after usage you should free it. +out: output parameter, contains pointer to loaded buffer. +outsize: output parameter, size of the allocated out buffer +filename: the path to the file to load +return value: error code (0 means ok) +*/ +unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename); + +/* +Save a file from buffer to disk. Warning, if it exists, this function overwrites +the file without warning! +buffer: the buffer to write +buffersize: size of the buffer to write +filename: the path to the file to save to +return value: error code (0 means ok) +*/ +unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename); +#endif /*LODEPNG_COMPILE_DISK*/ + +#ifdef LODEPNG_COMPILE_CPP +/* The LodePNG C++ wrapper uses std::vectors instead of manually allocated memory buffers. */ +namespace lodepng { +#ifdef LODEPNG_COMPILE_PNG +class State : public LodePNGState { + public: + State(); + State(const State& other); + ~State(); + State& operator=(const State& other); +}; + +#ifdef LODEPNG_COMPILE_DECODER +/* Same as other lodepng::decode, but using a State for more settings and information. */ +unsigned decode(std::vector& out, unsigned& w, unsigned& h, + State& state, + const unsigned char* in, size_t insize); +unsigned decode(std::vector& out, unsigned& w, unsigned& h, + State& state, + const std::vector& in); +#endif /*LODEPNG_COMPILE_DECODER*/ + +#ifdef LODEPNG_COMPILE_ENCODER +/* Same as other lodepng::encode, but using a State for more settings and information. */ +unsigned encode(std::vector& out, + const unsigned char* in, unsigned w, unsigned h, + State& state); +unsigned encode(std::vector& out, + const std::vector& in, unsigned w, unsigned h, + State& state); +#endif /*LODEPNG_COMPILE_ENCODER*/ + +#ifdef LODEPNG_COMPILE_DISK +/* +Load a file from disk into an std::vector. +return value: error code (0 means ok) +*/ +unsigned load_file(std::vector& buffer, const std::string& filename); + +/* +Save the binary data in an std::vector to a file on disk. The file is overwritten +without warning. +*/ +unsigned save_file(const std::vector& buffer, const std::string& filename); +#endif /* LODEPNG_COMPILE_DISK */ +#endif /* LODEPNG_COMPILE_PNG */ + +#ifdef LODEPNG_COMPILE_ZLIB +#ifdef LODEPNG_COMPILE_DECODER +/* Zlib-decompress an unsigned char buffer */ +unsigned decompress(std::vector& out, const unsigned char* in, size_t insize, + const LodePNGDecompressSettings& settings = lodepng_default_decompress_settings); + +/* Zlib-decompress an std::vector */ +unsigned decompress(std::vector& out, const std::vector& in, + const LodePNGDecompressSettings& settings = lodepng_default_decompress_settings); +#endif /* LODEPNG_COMPILE_DECODER */ + +#ifdef LODEPNG_COMPILE_ENCODER +/* Zlib-compress an unsigned char buffer */ +unsigned compress(std::vector& out, const unsigned char* in, size_t insize, + const LodePNGCompressSettings& settings = lodepng_default_compress_settings); + +/* Zlib-compress an std::vector */ +unsigned compress(std::vector& out, const std::vector& in, + const LodePNGCompressSettings& settings = lodepng_default_compress_settings); +#endif /* LODEPNG_COMPILE_ENCODER */ +#endif /* LODEPNG_COMPILE_ZLIB */ +} /* namespace lodepng */ +#endif /*LODEPNG_COMPILE_CPP*/ + +/* +TODO: +[.] test if there are no memory leaks or security exploits - done a lot but needs to be checked often +[.] check compatibility with various compilers - done but needs to be redone for every newer version +[X] converting color to 16-bit per channel types +[X] support color profile chunk types (but never let them touch RGB values by default) +[ ] support all public PNG chunk types (almost done except sBIT, sPLT and hIST) +[ ] make sure encoder generates no chunks with size > (2^31)-1 +[ ] partial decoding (stream processing) +[X] let the "isFullyOpaque" function check color keys and transparent palettes too +[X] better name for the variables "codes", "codesD", "codelengthcodes", "clcl" and "lldl" +[ ] allow treating some errors like warnings, when image is recoverable (e.g. 69, 57, 58) +[ ] make warnings like: oob palette, checksum fail, data after iend, wrong/unknown crit chunk, no null terminator in text, ... +[ ] error messages with line numbers (and version) +[ ] errors in state instead of as return code? +[ ] new errors/warnings like suspiciously big decompressed ztxt or iccp chunk +[ ] let the C++ wrapper catch exceptions coming from the standard library and return LodePNG error codes +[ ] allow user to provide custom color conversion functions, e.g. for premultiplied alpha, padding bits or not, ... +[ ] allow user to give data (void*) to custom allocator +[X] provide alternatives for C library functions not present on some platforms (memcpy, ...) +*/ + +#endif /*LODEPNG_H inclusion guard*/ + +/* +LodePNG Documentation +--------------------- + +0. table of contents +-------------------- + + 1. about + 1.1. supported features + 1.2. features not supported + 2. C and C++ version + 3. security + 4. decoding + 5. encoding + 6. color conversions + 6.1. PNG color types + 6.2. color conversions + 6.3. padding bits + 6.4. A note about 16-bits per channel and endianness + 7. error values + 8. chunks and PNG editing + 9. compiler support + 10. examples + 10.1. decoder C++ example + 10.2. decoder C example + 11. state settings reference + 12. changes + 13. contact information + + +1. about +-------- + +PNG is a file format to store raster images losslessly with good compression, +supporting different color types and alpha channel. + +LodePNG is a PNG codec according to the Portable Network Graphics (PNG) +Specification (Second Edition) - W3C Recommendation 10 November 2003. + +The specifications used are: + +*) Portable Network Graphics (PNG) Specification (Second Edition): + http://www.w3.org/TR/2003/REC-PNG-20031110 +*) RFC 1950 ZLIB Compressed Data Format version 3.3: + http://www.gzip.org/zlib/rfc-zlib.html +*) RFC 1951 DEFLATE Compressed Data Format Specification ver 1.3: + http://www.gzip.org/zlib/rfc-deflate.html + +The most recent version of LodePNG can currently be found at +http://lodev.org/lodepng/ + +LodePNG works both in C (ISO C90) and C++, with a C++ wrapper that adds +extra functionality. + +LodePNG exists out of two files: +-lodepng.h: the header file for both C and C++ +-lodepng.c(pp): give it the name lodepng.c or lodepng.cpp (or .cc) depending on your usage + +If you want to start using LodePNG right away without reading this doc, get the +examples from the LodePNG website to see how to use it in code, or check the +smaller examples in chapter 13 here. + +LodePNG is simple but only supports the basic requirements. To achieve +simplicity, the following design choices were made: There are no dependencies +on any external library. There are functions to decode and encode a PNG with +a single function call, and extended versions of these functions taking a +LodePNGState struct allowing to specify or get more information. By default +the colors of the raw image are always RGB or RGBA, no matter what color type +the PNG file uses. To read and write files, there are simple functions to +convert the files to/from buffers in memory. + +This all makes LodePNG suitable for loading textures in games, demos and small +programs, ... It's less suitable for full fledged image editors, loading PNGs +over network (it requires all the image data to be available before decoding can +begin), life-critical systems, ... + +1.1. supported features +----------------------- + +The following features are supported by the decoder: + +*) decoding of PNGs with any color type, bit depth and interlace mode, to a 24- or 32-bit color raw image, + or the same color type as the PNG +*) encoding of PNGs, from any raw image to 24- or 32-bit color, or the same color type as the raw image +*) Adam7 interlace and deinterlace for any color type +*) loading the image from harddisk or decoding it from a buffer from other sources than harddisk +*) support for alpha channels, including RGBA color model, translucent palettes and color keying +*) zlib decompression (inflate) +*) zlib compression (deflate) +*) CRC32 and ADLER32 checksums +*) colorimetric color profile conversions: currently experimentally available in lodepng_util.cpp only, + plus alternatively ability to pass on chroma/gamma/ICC profile information to other color management system. +*) handling of unknown chunks, allowing making a PNG editor that stores custom and unknown chunks. +*) the following chunks are supported by both encoder and decoder: + IHDR: header information + PLTE: color palette + IDAT: pixel data + IEND: the final chunk + tRNS: transparency for palettized images + tEXt: textual information + zTXt: compressed textual information + iTXt: international textual information + bKGD: suggested background color + pHYs: physical dimensions + tIME: modification time + cHRM: RGB chromaticities + gAMA: RGB gamma correction + iCCP: ICC color profile + sRGB: rendering intent + +1.2. features not supported +--------------------------- + +The following features are _not_ supported: + +*) some features needed to make a conformant PNG-Editor might be still missing. +*) partial loading/stream processing. All data must be available and is processed in one call. +*) The following public chunks are not (yet) supported but treated as unknown chunks by LodePNG: + sBIT + hIST + sPLT + + +2. C and C++ version +-------------------- + +The C version uses buffers allocated with alloc that you need to free() +yourself. You need to use init and cleanup functions for each struct whenever +using a struct from the C version to avoid exploits and memory leaks. + +The C++ version has extra functions with std::vectors in the interface and the +lodepng::State class which is a LodePNGState with constructor and destructor. + +These files work without modification for both C and C++ compilers because all +the additional C++ code is in "#ifdef __cplusplus" blocks that make C-compilers +ignore it, and the C code is made to compile both with strict ISO C90 and C++. + +To use the C++ version, you need to rename the source file to lodepng.cpp +(instead of lodepng.c), and compile it with a C++ compiler. + +To use the C version, you need to rename the source file to lodepng.c (instead +of lodepng.cpp), and compile it with a C compiler. + + +3. Security +----------- + +Even if carefully designed, it's always possible that LodePNG contains possible +exploits. If you discover one, please let me know, and it will be fixed. + +When using LodePNG, care has to be taken with the C version of LodePNG, as well +as the C-style structs when working with C++. The following conventions are used +for all C-style structs: + +-if a struct has a corresponding init function, always call the init function when making a new one +-if a struct has a corresponding cleanup function, call it before the struct disappears to avoid memory leaks +-if a struct has a corresponding copy function, use the copy function instead of "=". + The destination must also be inited already. + + +4. Decoding +----------- + +Decoding converts a PNG compressed image to a raw pixel buffer. + +Most documentation on using the decoder is at its declarations in the header +above. For C, simple decoding can be done with functions such as +lodepng_decode32, and more advanced decoding can be done with the struct +LodePNGState and lodepng_decode. For C++, all decoding can be done with the +various lodepng::decode functions, and lodepng::State can be used for advanced +features. + +When using the LodePNGState, it uses the following fields for decoding: +*) LodePNGInfo info_png: it stores extra information about the PNG (the input) in here +*) LodePNGColorMode info_raw: here you can say what color mode of the raw image (the output) you want to get +*) LodePNGDecoderSettings decoder: you can specify a few extra settings for the decoder to use + +LodePNGInfo info_png +-------------------- + +After decoding, this contains extra information of the PNG image, except the actual +pixels, width and height because these are already gotten directly from the decoder +functions. + +It contains for example the original color type of the PNG image, text comments, +suggested background color, etc... More details about the LodePNGInfo struct are +at its declaration documentation. + +LodePNGColorMode info_raw +------------------------- + +When decoding, here you can specify which color type you want +the resulting raw image to be. If this is different from the colortype of the +PNG, then the decoder will automatically convert the result. This conversion +always works, except if you want it to convert a color PNG to grayscale or to +a palette with missing colors. + +By default, 32-bit color is used for the result. + +LodePNGDecoderSettings decoder +------------------------------ + +The settings can be used to ignore the errors created by invalid CRC and Adler32 +chunks, and to disable the decoding of tEXt chunks. + +There's also a setting color_convert, true by default. If false, no conversion +is done, the resulting data will be as it was in the PNG (after decompression) +and you'll have to puzzle the colors of the pixels together yourself using the +color type information in the LodePNGInfo. + + +5. Encoding +----------- + +Encoding converts a raw pixel buffer to a PNG compressed image. + +Most documentation on using the encoder is at its declarations in the header +above. For C, simple encoding can be done with functions such as +lodepng_encode32, and more advanced decoding can be done with the struct +LodePNGState and lodepng_encode. For C++, all encoding can be done with the +various lodepng::encode functions, and lodepng::State can be used for advanced +features. + +Like the decoder, the encoder can also give errors. However it gives less errors +since the encoder input is trusted, the decoder input (a PNG image that could +be forged by anyone) is not trusted. + +When using the LodePNGState, it uses the following fields for encoding: +*) LodePNGInfo info_png: here you specify how you want the PNG (the output) to be. +*) LodePNGColorMode info_raw: here you say what color type of the raw image (the input) has +*) LodePNGEncoderSettings encoder: you can specify a few settings for the encoder to use + +LodePNGInfo info_png +-------------------- + +When encoding, you use this the opposite way as when decoding: for encoding, +you fill in the values you want the PNG to have before encoding. By default it's +not needed to specify a color type for the PNG since it's automatically chosen, +but it's possible to choose it yourself given the right settings. + +The encoder will not always exactly match the LodePNGInfo struct you give, +it tries as close as possible. Some things are ignored by the encoder. The +encoder uses, for example, the following settings from it when applicable: +colortype and bitdepth, text chunks, time chunk, the color key, the palette, the +background color, the interlace method, unknown chunks, ... + +When encoding to a PNG with colortype 3, the encoder will generate a PLTE chunk. +If the palette contains any colors for which the alpha channel is not 255 (so +there are translucent colors in the palette), it'll add a tRNS chunk. + +LodePNGColorMode info_raw +------------------------- + +You specify the color type of the raw image that you give to the input here, +including a possible transparent color key and palette you happen to be using in +your raw image data. + +By default, 32-bit color is assumed, meaning your input has to be in RGBA +format with 4 bytes (unsigned chars) per pixel. + +LodePNGEncoderSettings encoder +------------------------------ + +The following settings are supported (some are in sub-structs): +*) auto_convert: when this option is enabled, the encoder will +automatically choose the smallest possible color mode (including color key) that +can encode the colors of all pixels without information loss. +*) btype: the block type for LZ77. 0 = uncompressed, 1 = fixed huffman tree, + 2 = dynamic huffman tree (best compression). Should be 2 for proper + compression. +*) use_lz77: whether or not to use LZ77 for compressed block types. Should be + true for proper compression. +*) windowsize: the window size used by the LZ77 encoder (1 - 32768). Has value + 2048 by default, but can be set to 32768 for better, but slow, compression. +*) force_palette: if colortype is 2 or 6, you can make the encoder write a PLTE + chunk if force_palette is true. This can used as suggested palette to convert + to by viewers that don't support more than 256 colors (if those still exist) +*) add_id: add text chunk "Encoder: LodePNG " to the image. +*) text_compression: default 1. If 1, it'll store texts as zTXt instead of tEXt chunks. + zTXt chunks use zlib compression on the text. This gives a smaller result on + large texts but a larger result on small texts (such as a single program name). + It's all tEXt or all zTXt though, there's no separate setting per text yet. + + +6. color conversions +-------------------- + +An important thing to note about LodePNG, is that the color type of the PNG, and +the color type of the raw image, are completely independent. By default, when +you decode a PNG, you get the result as a raw image in the color type you want, +no matter whether the PNG was encoded with a palette, grayscale or RGBA color. +And if you encode an image, by default LodePNG will automatically choose the PNG +color type that gives good compression based on the values of colors and amount +of colors in the image. It can be configured to let you control it instead as +well, though. + +To be able to do this, LodePNG does conversions from one color mode to another. +It can convert from almost any color type to any other color type, except the +following conversions: RGB to grayscale is not supported, and converting to a +palette when the palette doesn't have a required color is not supported. This is +not supported on purpose: this is information loss which requires a color +reduction algorithm that is beyond the scope of a PNG encoder (yes, RGB to gray +is easy, but there are multiple ways if you want to give some channels more +weight). + +By default, when decoding, you get the raw image in 32-bit RGBA or 24-bit RGB +color, no matter what color type the PNG has. And by default when encoding, +LodePNG automatically picks the best color model for the output PNG, and expects +the input image to be 32-bit RGBA or 24-bit RGB. So, unless you want to control +the color format of the images yourself, you can skip this chapter. + +6.1. PNG color types +-------------------- + +A PNG image can have many color types, ranging from 1-bit color to 64-bit color, +as well as palettized color modes. After the zlib decompression and unfiltering +in the PNG image is done, the raw pixel data will have that color type and thus +a certain amount of bits per pixel. If you want the output raw image after +decoding to have another color type, a conversion is done by LodePNG. + +The PNG specification gives the following color types: + +0: grayscale, bit depths 1, 2, 4, 8, 16 +2: RGB, bit depths 8 and 16 +3: palette, bit depths 1, 2, 4 and 8 +4: grayscale with alpha, bit depths 8 and 16 +6: RGBA, bit depths 8 and 16 + +Bit depth is the amount of bits per pixel per color channel. So the total amount +of bits per pixel is: amount of channels * bitdepth. + +6.2. color conversions +---------------------- + +As explained in the sections about the encoder and decoder, you can specify +color types and bit depths in info_png and info_raw to change the default +behaviour. + +If, when decoding, you want the raw image to be something else than the default, +you need to set the color type and bit depth you want in the LodePNGColorMode, +or the parameters colortype and bitdepth of the simple decoding function. + +If, when encoding, you use another color type than the default in the raw input +image, you need to specify its color type and bit depth in the LodePNGColorMode +of the raw image, or use the parameters colortype and bitdepth of the simple +encoding function. + +If, when encoding, you don't want LodePNG to choose the output PNG color type +but control it yourself, you need to set auto_convert in the encoder settings +to false, and specify the color type you want in the LodePNGInfo of the +encoder (including palette: it can generate a palette if auto_convert is true, +otherwise not). + +If the input and output color type differ (whether user chosen or auto chosen), +LodePNG will do a color conversion, which follows the rules below, and may +sometimes result in an error. + +To avoid some confusion: +-the decoder converts from PNG to raw image +-the encoder converts from raw image to PNG +-the colortype and bitdepth in LodePNGColorMode info_raw, are those of the raw image +-the colortype and bitdepth in the color field of LodePNGInfo info_png, are those of the PNG +-when encoding, the color type in LodePNGInfo is ignored if auto_convert + is enabled, it is automatically generated instead +-when decoding, the color type in LodePNGInfo is set by the decoder to that of the original + PNG image, but it can be ignored since the raw image has the color type you requested instead +-if the color type of the LodePNGColorMode and PNG image aren't the same, a conversion + between the color types is done if the color types are supported. If it is not + supported, an error is returned. If the types are the same, no conversion is done. +-even though some conversions aren't supported, LodePNG supports loading PNGs from any + colortype and saving PNGs to any colortype, sometimes it just requires preparing + the raw image correctly before encoding. +-both encoder and decoder use the same color converter. + +The function lodepng_convert does the color conversion. It is available in the +interface but normally isn't needed since the encoder and decoder already call +it. + +Non supported color conversions: +-color to grayscale when non-gray pixels are present: no error is thrown, but +the result will look ugly because only the red channel is taken (it assumes all +three channels are the same in this case so ignores green and blue). The reason +no error is given is to allow converting from three-channel grayscale images to +one-channel even if there are numerical imprecisions. +-anything to palette when the palette does not have an exact match for a from-color +in it: in this case an error is thrown + +Supported color conversions: +-anything to 8-bit RGB, 8-bit RGBA, 16-bit RGB, 16-bit RGBA +-any gray or gray+alpha, to gray or gray+alpha +-anything to a palette, as long as the palette has the requested colors in it +-removing alpha channel +-higher to smaller bitdepth, and vice versa + +If you want no color conversion to be done (e.g. for speed or control): +-In the encoder, you can make it save a PNG with any color type by giving the +raw color mode and LodePNGInfo the same color mode, and setting auto_convert to +false. +-In the decoder, you can make it store the pixel data in the same color type +as the PNG has, by setting the color_convert setting to false. Settings in +info_raw are then ignored. + +6.3. padding bits +----------------- + +In the PNG file format, if a less than 8-bit per pixel color type is used and the scanlines +have a bit amount that isn't a multiple of 8, then padding bits are used so that each +scanline starts at a fresh byte. But that is NOT true for the LodePNG raw input and output. +The raw input image you give to the encoder, and the raw output image you get from the decoder +will NOT have these padding bits, e.g. in the case of a 1-bit image with a width +of 7 pixels, the first pixel of the second scanline will the 8th bit of the first byte, +not the first bit of a new byte. + +6.4. A note about 16-bits per channel and endianness +---------------------------------------------------- + +LodePNG uses unsigned char arrays for 16-bit per channel colors too, just like +for any other color format. The 16-bit values are stored in big endian (most +significant byte first) in these arrays. This is the opposite order of the +little endian used by x86 CPU's. + +LodePNG always uses big endian because the PNG file format does so internally. +Conversions to other formats than PNG uses internally are not supported by +LodePNG on purpose, there are myriads of formats, including endianness of 16-bit +colors, the order in which you store R, G, B and A, and so on. Supporting and +converting to/from all that is outside the scope of LodePNG. + +This may mean that, depending on your use case, you may want to convert the big +endian output of LodePNG to little endian with a for loop. This is certainly not +always needed, many applications and libraries support big endian 16-bit colors +anyway, but it means you cannot simply cast the unsigned char* buffer to an +unsigned short* buffer on x86 CPUs. + + +7. error values +--------------- + +All functions in LodePNG that return an error code, return 0 if everything went +OK, or a non-zero code if there was an error. + +The meaning of the LodePNG error values can be retrieved with the function +lodepng_error_text: given the numerical error code, it returns a description +of the error in English as a string. + +Check the implementation of lodepng_error_text to see the meaning of each code. + +It is not recommended to use the numerical values to programmatically make +different decisions based on error types as the numbers are not guaranteed to +stay backwards compatible. They are for human consumption only. Programmatically +only 0 or non-0 matter. + + +8. chunks and PNG editing +------------------------- + +If you want to add extra chunks to a PNG you encode, or use LodePNG for a PNG +editor that should follow the rules about handling of unknown chunks, or if your +program is able to read other types of chunks than the ones handled by LodePNG, +then that's possible with the chunk functions of LodePNG. + +A PNG chunk has the following layout: + +4 bytes length +4 bytes type name +length bytes data +4 bytes CRC + +8.1. iterating through chunks +----------------------------- + +If you have a buffer containing the PNG image data, then the first chunk (the +IHDR chunk) starts at byte number 8 of that buffer. The first 8 bytes are the +signature of the PNG and are not part of a chunk. But if you start at byte 8 +then you have a chunk, and can check the following things of it. + +NOTE: none of these functions check for memory buffer boundaries. To avoid +exploits, always make sure the buffer contains all the data of the chunks. +When using lodepng_chunk_next, make sure the returned value is within the +allocated memory. + +unsigned lodepng_chunk_length(const unsigned char* chunk): + +Get the length of the chunk's data. The total chunk length is this length + 12. + +void lodepng_chunk_type(char type[5], const unsigned char* chunk): +unsigned char lodepng_chunk_type_equals(const unsigned char* chunk, const char* type): + +Get the type of the chunk or compare if it's a certain type + +unsigned char lodepng_chunk_critical(const unsigned char* chunk): +unsigned char lodepng_chunk_private(const unsigned char* chunk): +unsigned char lodepng_chunk_safetocopy(const unsigned char* chunk): + +Check if the chunk is critical in the PNG standard (only IHDR, PLTE, IDAT and IEND are). +Check if the chunk is private (public chunks are part of the standard, private ones not). +Check if the chunk is safe to copy. If it's not, then, when modifying data in a critical +chunk, unsafe to copy chunks of the old image may NOT be saved in the new one if your +program doesn't handle that type of unknown chunk. + +unsigned char* lodepng_chunk_data(unsigned char* chunk): +const unsigned char* lodepng_chunk_data_const(const unsigned char* chunk): + +Get a pointer to the start of the data of the chunk. + +unsigned lodepng_chunk_check_crc(const unsigned char* chunk): +void lodepng_chunk_generate_crc(unsigned char* chunk): + +Check if the crc is correct or generate a correct one. + +unsigned char* lodepng_chunk_next(unsigned char* chunk): +const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk): + +Iterate to the next chunk. This works if you have a buffer with consecutive chunks. Note that these +functions do no boundary checking of the allocated data whatsoever, so make sure there is enough +data available in the buffer to be able to go to the next chunk. + +unsigned lodepng_chunk_append(unsigned char** out, size_t* outsize, const unsigned char* chunk): +unsigned lodepng_chunk_create(unsigned char** out, size_t* outsize, unsigned length, + const char* type, const unsigned char* data): + +These functions are used to create new chunks that are appended to the data in *out that has +length *outsize. The append function appends an existing chunk to the new data. The create +function creates a new chunk with the given parameters and appends it. Type is the 4-letter +name of the chunk. + +8.2. chunks in info_png +----------------------- + +The LodePNGInfo struct contains fields with the unknown chunk in it. It has 3 +buffers (each with size) to contain 3 types of unknown chunks: +the ones that come before the PLTE chunk, the ones that come between the PLTE +and the IDAT chunks, and the ones that come after the IDAT chunks. +It's necessary to make the distinction between these 3 cases because the PNG +standard forces to keep the ordering of unknown chunks compared to the critical +chunks, but does not force any other ordering rules. + +info_png.unknown_chunks_data[0] is the chunks before PLTE +info_png.unknown_chunks_data[1] is the chunks after PLTE, before IDAT +info_png.unknown_chunks_data[2] is the chunks after IDAT + +The chunks in these 3 buffers can be iterated through and read by using the same +way described in the previous subchapter. + +When using the decoder to decode a PNG, you can make it store all unknown chunks +if you set the option settings.remember_unknown_chunks to 1. By default, this +option is off (0). + +The encoder will always encode unknown chunks that are stored in the info_png. +If you need it to add a particular chunk that isn't known by LodePNG, you can +use lodepng_chunk_append or lodepng_chunk_create to the chunk data in +info_png.unknown_chunks_data[x]. + +Chunks that are known by LodePNG should not be added in that way. E.g. to make +LodePNG add a bKGD chunk, set background_defined to true and add the correct +parameters there instead. + + +9. compiler support +------------------- + +No libraries other than the current standard C library are needed to compile +LodePNG. For the C++ version, only the standard C++ library is needed on top. +Add the files lodepng.c(pp) and lodepng.h to your project, include +lodepng.h where needed, and your program can read/write PNG files. + +It is compatible with C90 and up, and C++03 and up. + +If performance is important, use optimization when compiling! For both the +encoder and decoder, this makes a large difference. + +Make sure that LodePNG is compiled with the same compiler of the same version +and with the same settings as the rest of the program, or the interfaces with +std::vectors and std::strings in C++ can be incompatible. + +CHAR_BITS must be 8 or higher, because LodePNG uses unsigned chars for octets. + +*) gcc and g++ + +LodePNG is developed in gcc so this compiler is natively supported. It gives no +warnings with compiler options "-Wall -Wextra -pedantic -ansi", with gcc and g++ +version 4.7.1 on Linux, 32-bit and 64-bit. + +*) Clang + +Fully supported and warning-free. + +*) Mingw + +The Mingw compiler (a port of gcc for Windows) should be fully supported by +LodePNG. + +*) Visual Studio and Visual C++ Express Edition + +LodePNG should be warning-free with warning level W4. Two warnings were disabled +with pragmas though: warning 4244 about implicit conversions, and warning 4996 +where it wants to use a non-standard function fopen_s instead of the standard C +fopen. + +Visual Studio may want "stdafx.h" files to be included in each source file and +give an error "unexpected end of file while looking for precompiled header". +This is not standard C++ and will not be added to the stock LodePNG. You can +disable it for lodepng.cpp only by right clicking it, Properties, C/C++, +Precompiled Headers, and set it to Not Using Precompiled Headers there. + +NOTE: Modern versions of VS should be fully supported, but old versions, e.g. +VS6, are not guaranteed to work. + +*) Compilers on Macintosh + +LodePNG has been reported to work both with gcc and LLVM for Macintosh, both for +C and C++. + +*) Other Compilers + +If you encounter problems on any compilers, feel free to let me know and I may +try to fix it if the compiler is modern and standards compliant. + + +10. examples +------------ + +This decoder example shows the most basic usage of LodePNG. More complex +examples can be found on the LodePNG website. + +10.1. decoder C++ example +------------------------- + +#include "lodepng.h" +#include + +int main(int argc, char *argv[]) { + const char* filename = argc > 1 ? argv[1] : "test.png"; + + //load and decode + std::vector image; + unsigned width, height; + unsigned error = lodepng::decode(image, width, height, filename); + + //if there's an error, display it + if(error) std::cout << "decoder error " << error << ": " << lodepng_error_text(error) << std::endl; + + //the pixels are now in the vector "image", 4 bytes per pixel, ordered RGBARGBA..., use it as texture, draw it, ... +} + +10.2. decoder C example +----------------------- + +#include "lodepng.h" + +int main(int argc, char *argv[]) { + unsigned error; + unsigned char* image; + size_t width, height; + const char* filename = argc > 1 ? argv[1] : "test.png"; + + error = lodepng_decode32_file(&image, &width, &height, filename); + + if(error) printf("decoder error %u: %s\n", error, lodepng_error_text(error)); + + / * use image here * / + + free(image); + return 0; +} + +11. state settings reference +---------------------------- + +A quick reference of some settings to set on the LodePNGState + +For decoding: + +state.decoder.zlibsettings.ignore_adler32: ignore ADLER32 checksums +state.decoder.zlibsettings.custom_...: use custom inflate function +state.decoder.ignore_crc: ignore CRC checksums +state.decoder.ignore_critical: ignore unknown critical chunks +state.decoder.ignore_end: ignore missing IEND chunk. May fail if this corruption causes other errors +state.decoder.color_convert: convert internal PNG color to chosen one +state.decoder.read_text_chunks: whether to read in text metadata chunks +state.decoder.remember_unknown_chunks: whether to read in unknown chunks +state.info_raw.colortype: desired color type for decoded image +state.info_raw.bitdepth: desired bit depth for decoded image +state.info_raw....: more color settings, see struct LodePNGColorMode +state.info_png....: no settings for decoder but ouput, see struct LodePNGInfo + +For encoding: + +state.encoder.zlibsettings.btype: disable compression by setting it to 0 +state.encoder.zlibsettings.use_lz77: use LZ77 in compression +state.encoder.zlibsettings.windowsize: tweak LZ77 windowsize +state.encoder.zlibsettings.minmatch: tweak min LZ77 length to match +state.encoder.zlibsettings.nicematch: tweak LZ77 match where to stop searching +state.encoder.zlibsettings.lazymatching: try one more LZ77 matching +state.encoder.zlibsettings.custom_...: use custom deflate function +state.encoder.auto_convert: choose optimal PNG color type, if 0 uses info_png +state.encoder.filter_palette_zero: PNG filter strategy for palette +state.encoder.filter_strategy: PNG filter strategy to encode with +state.encoder.force_palette: add palette even if not encoding to one +state.encoder.add_id: add LodePNG identifier and version as a text chunk +state.encoder.text_compression: use compressed text chunks for metadata +state.info_raw.colortype: color type of raw input image you provide +state.info_raw.bitdepth: bit depth of raw input image you provide +state.info_raw: more color settings, see struct LodePNGColorMode +state.info_png.color.colortype: desired color type if auto_convert is false +state.info_png.color.bitdepth: desired bit depth if auto_convert is false +state.info_png.color....: more color settings, see struct LodePNGColorMode +state.info_png....: more PNG related settings, see struct LodePNGInfo + + +12. changes +----------- + +The version number of LodePNG is the date of the change given in the format +yyyymmdd. + +Some changes aren't backwards compatible. Those are indicated with a (!) +symbol. + +Not all changes are listed here, the commit history in github lists more: +https://github.com/lvandeve/lodepng + +*) 17 okt 2020: prevent decoding too large text/icc chunks by default. +*) 06 mar 2020: simplified some of the dynamic memory allocations. +*) 12 jan 2020: (!) added 'end' argument to lodepng_chunk_next to allow correct + overflow checks. +*) 14 aug 2019: around 25% faster decoding thanks to huffman lookup tables. +*) 15 jun 2019: (!) auto_choose_color API changed (for bugfix: don't use palette + if gray ICC profile) and non-ICC LodePNGColorProfile renamed to + LodePNGColorStats. +*) 30 dec 2018: code style changes only: removed newlines before opening braces. +*) 10 sep 2018: added way to inspect metadata chunks without full decoding. +*) 19 aug 2018: (!) fixed color mode bKGD is encoded with and made it use + palette index in case of palette. +*) 10 aug 2018: (!) added support for gAMA, cHRM, sRGB and iCCP chunks. This + change is backwards compatible unless you relied on unknown_chunks for those. +*) 11 jun 2018: less restrictive check for pixel size integer overflow +*) 14 jan 2018: allow optionally ignoring a few more recoverable errors +*) 17 sep 2017: fix memory leak for some encoder input error cases +*) 27 nov 2016: grey+alpha auto color model detection bugfix +*) 18 apr 2016: Changed qsort to custom stable sort (for platforms w/o qsort). +*) 09 apr 2016: Fixed colorkey usage detection, and better file loading (within + the limits of pure C90). +*) 08 dec 2015: Made load_file function return error if file can't be opened. +*) 24 okt 2015: Bugfix with decoding to palette output. +*) 18 apr 2015: Boundary PM instead of just package-merge for faster encoding. +*) 24 aug 2014: Moved to github +*) 23 aug 2014: Reduced needless memory usage of decoder. +*) 28 jun 2014: Removed fix_png setting, always support palette OOB for + simplicity. Made ColorProfile public. +*) 09 jun 2014: Faster encoder by fixing hash bug and more zeros optimization. +*) 22 dec 2013: Power of two windowsize required for optimization. +*) 15 apr 2013: Fixed bug with LAC_ALPHA and color key. +*) 25 mar 2013: Added an optional feature to ignore some PNG errors (fix_png). +*) 11 mar 2013: (!) Bugfix with custom free. Changed from "my" to "lodepng_" + prefix for the custom allocators and made it possible with a new #define to + use custom ones in your project without needing to change lodepng's code. +*) 28 jan 2013: Bugfix with color key. +*) 27 okt 2012: Tweaks in text chunk keyword length error handling. +*) 8 okt 2012: (!) Added new filter strategy (entropy) and new auto color mode. + (no palette). Better deflate tree encoding. New compression tweak settings. + Faster color conversions while decoding. Some internal cleanups. +*) 23 sep 2012: Reduced warnings in Visual Studio a little bit. +*) 1 sep 2012: (!) Removed #define's for giving custom (de)compression functions + and made it work with function pointers instead. +*) 23 jun 2012: Added more filter strategies. Made it easier to use custom alloc + and free functions and toggle #defines from compiler flags. Small fixes. +*) 6 may 2012: (!) Made plugging in custom zlib/deflate functions more flexible. +*) 22 apr 2012: (!) Made interface more consistent, renaming a lot. Removed + redundant C++ codec classes. Reduced amount of structs. Everything changed, + but it is cleaner now imho and functionality remains the same. Also fixed + several bugs and shrunk the implementation code. Made new samples. +*) 6 nov 2011: (!) By default, the encoder now automatically chooses the best + PNG color model and bit depth, based on the amount and type of colors of the + raw image. For this, autoLeaveOutAlphaChannel replaced by auto_choose_color. +*) 9 okt 2011: simpler hash chain implementation for the encoder. +*) 8 sep 2011: lz77 encoder lazy matching instead of greedy matching. +*) 23 aug 2011: tweaked the zlib compression parameters after benchmarking. + A bug with the PNG filtertype heuristic was fixed, so that it chooses much + better ones (it's quite significant). A setting to do an experimental, slow, + brute force search for PNG filter types is added. +*) 17 aug 2011: (!) changed some C zlib related function names. +*) 16 aug 2011: made the code less wide (max 120 characters per line). +*) 17 apr 2011: code cleanup. Bugfixes. Convert low to 16-bit per sample colors. +*) 21 feb 2011: fixed compiling for C90. Fixed compiling with sections disabled. +*) 11 dec 2010: encoding is made faster, based on suggestion by Peter Eastman + to optimize long sequences of zeros. +*) 13 nov 2010: added LodePNG_InfoColor_hasPaletteAlpha and + LodePNG_InfoColor_canHaveAlpha functions for convenience. +*) 7 nov 2010: added LodePNG_error_text function to get error code description. +*) 30 okt 2010: made decoding slightly faster +*) 26 okt 2010: (!) changed some C function and struct names (more consistent). + Reorganized the documentation and the declaration order in the header. +*) 08 aug 2010: only changed some comments and external samples. +*) 05 jul 2010: fixed bug thanks to warnings in the new gcc version. +*) 14 mar 2010: fixed bug where too much memory was allocated for char buffers. +*) 02 sep 2008: fixed bug where it could create empty tree that linux apps could + read by ignoring the problem but windows apps couldn't. +*) 06 jun 2008: added more error checks for out of memory cases. +*) 26 apr 2008: added a few more checks here and there to ensure more safety. +*) 06 mar 2008: crash with encoding of strings fixed +*) 02 feb 2008: support for international text chunks added (iTXt) +*) 23 jan 2008: small cleanups, and #defines to divide code in sections +*) 20 jan 2008: support for unknown chunks allowing using LodePNG for an editor. +*) 18 jan 2008: support for tIME and pHYs chunks added to encoder and decoder. +*) 17 jan 2008: ability to encode and decode compressed zTXt chunks added + Also various fixes, such as in the deflate and the padding bits code. +*) 13 jan 2008: Added ability to encode Adam7-interlaced images. Improved + filtering code of encoder. +*) 07 jan 2008: (!) changed LodePNG to use ISO C90 instead of C++. A + C++ wrapper around this provides an interface almost identical to before. + Having LodePNG be pure ISO C90 makes it more portable. The C and C++ code + are together in these files but it works both for C and C++ compilers. +*) 29 dec 2007: (!) changed most integer types to unsigned int + other tweaks +*) 30 aug 2007: bug fixed which makes this Borland C++ compatible +*) 09 aug 2007: some VS2005 warnings removed again +*) 21 jul 2007: deflate code placed in new namespace separate from zlib code +*) 08 jun 2007: fixed bug with 2- and 4-bit color, and small interlaced images +*) 04 jun 2007: improved support for Visual Studio 2005: crash with accessing + invalid std::vector element [0] fixed, and level 3 and 4 warnings removed +*) 02 jun 2007: made the encoder add a tag with version by default +*) 27 may 2007: zlib and png code separated (but still in the same file), + simple encoder/decoder functions added for more simple usage cases +*) 19 may 2007: minor fixes, some code cleaning, new error added (error 69), + moved some examples from here to lodepng_examples.cpp +*) 12 may 2007: palette decoding bug fixed +*) 24 apr 2007: changed the license from BSD to the zlib license +*) 11 mar 2007: very simple addition: ability to encode bKGD chunks. +*) 04 mar 2007: (!) tEXt chunk related fixes, and support for encoding + palettized PNG images. Plus little interface change with palette and texts. +*) 03 mar 2007: Made it encode dynamic Huffman shorter with repeat codes. + Fixed a bug where the end code of a block had length 0 in the Huffman tree. +*) 26 feb 2007: Huffman compression with dynamic trees (BTYPE 2) now implemented + and supported by the encoder, resulting in smaller PNGs at the output. +*) 27 jan 2007: Made the Adler-32 test faster so that a timewaste is gone. +*) 24 jan 2007: gave encoder an error interface. Added color conversion from any + greyscale type to 8-bit greyscale with or without alpha. +*) 21 jan 2007: (!) Totally changed the interface. It allows more color types + to convert to and is more uniform. See the manual for how it works now. +*) 07 jan 2007: Some cleanup & fixes, and a few changes over the last days: + encode/decode custom tEXt chunks, separate classes for zlib & deflate, and + at last made the decoder give errors for incorrect Adler32 or Crc. +*) 01 jan 2007: Fixed bug with encoding PNGs with less than 8 bits per channel. +*) 29 dec 2006: Added support for encoding images without alpha channel, and + cleaned out code as well as making certain parts faster. +*) 28 dec 2006: Added "Settings" to the encoder. +*) 26 dec 2006: The encoder now does LZ77 encoding and produces much smaller files now. + Removed some code duplication in the decoder. Fixed little bug in an example. +*) 09 dec 2006: (!) Placed output parameters of public functions as first parameter. + Fixed a bug of the decoder with 16-bit per color. +*) 15 okt 2006: Changed documentation structure +*) 09 okt 2006: Encoder class added. It encodes a valid PNG image from the + given image buffer, however for now it's not compressed. +*) 08 sep 2006: (!) Changed to interface with a Decoder class +*) 30 jul 2006: (!) LodePNG_InfoPng , width and height are now retrieved in different + way. Renamed decodePNG to decodePNGGeneric. +*) 29 jul 2006: (!) Changed the interface: image info is now returned as a + struct of type LodePNG::LodePNG_Info, instead of a vector, which was a bit clumsy. +*) 28 jul 2006: Cleaned the code and added new error checks. + Corrected terminology "deflate" into "inflate". +*) 23 jun 2006: Added SDL example in the documentation in the header, this + example allows easy debugging by displaying the PNG and its transparency. +*) 22 jun 2006: (!) Changed way to obtain error value. Added + loadFile function for convenience. Made decodePNG32 faster. +*) 21 jun 2006: (!) Changed type of info vector to unsigned. + Changed position of palette in info vector. Fixed an important bug that + happened on PNGs with an uncompressed block. +*) 16 jun 2006: Internally changed unsigned into unsigned where + needed, and performed some optimizations. +*) 07 jun 2006: (!) Renamed functions to decodePNG and placed them + in LodePNG namespace. Changed the order of the parameters. Rewrote the + documentation in the header. Renamed files to lodepng.cpp and lodepng.h +*) 22 apr 2006: Optimized and improved some code +*) 07 sep 2005: (!) Changed to std::vector interface +*) 12 aug 2005: Initial release (C++, decoder only) + + +13. contact information +----------------------- + +Feel free to contact me with suggestions, problems, comments, ... concerning +LodePNG. If you encounter a PNG image that doesn't work properly with this +decoder, feel free to send it and I'll use it to find and fix the problem. + +My email address is (puzzle the account and domain together with an @ symbol): +Domain: gmail dot com. +Account: lode dot vandevenne. + + +Copyright (c) 2005-2020 Lode Vandevenne +*/ diff --git a/depends/lua/CMakeLists.txt b/depends/lua/CMakeLists.txt index b77bce6f7c..44b16e56cc 100644 --- a/depends/lua/CMakeLists.txt +++ b/depends/lua/CMakeLists.txt @@ -1,103 +1,112 @@ -PROJECT ( lua CXX ) -CMAKE_MINIMUM_REQUIRED(VERSION 2.8) +project(lua CXX) +cmake_minimum_required(VERSION 3.21) -SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DLUA_USE_APICHECK") +set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DLUA_USE_APICHECK") -IF(WIN32) - ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE ) -ELSE() - ADD_DEFINITIONS ( -DLUA_USE_POSIX -DLUA_USE_DLOPEN ) - SET ( LIBS m dl ) -ENDIF() +# Make bit32 library available (for things like bit32.extract()) +add_definitions(-DLUA_COMPAT_BITLIB) -IF(UNIX) - add_definitions(-DLINUX_BUILD) - SET(CMAKE_C_FLAGS "-m32") -ENDIF() +if(WIN32) + add_definitions(-D_CRT_SECURE_NO_DEPRECATE /wd4334) +else() + add_definitions(-DLUA_USE_POSIX -DLUA_USE_DLOPEN) + set(LIBS m dl) +endif() -SET (HDR_LIBLUA -include/lapi.h -include/lauxlib.h -include/lcode.h -include/lctype.h -include/ldebug.h -include/ldo.h -include/lfunc.h -include/lgc.h -include/llex.h -include/llimits.h -include/lmem.h -include/lobject.h -include/lopcodes.h -include/lparser.h -include/lstate.h -include/lstring.h -include/ltable.h -include/ltm.h -include/lua.h -include/luaconf.h -include/lualib.h -include/lundump.h -include/lvm.h -include/lzio.h +if(UNIX) + add_definitions(-DLINUX_BUILD) + if(DFHACK_BUILD_64) + set(CMAKE_C_FLAGS "-m64 -mno-avx") + else() + set(CMAKE_C_FLAGS "-m32") + endif() +endif() + +set(HDR_LIBLUA + include/lapi.h + include/lauxlib.h + include/lcode.h + include/lctype.h + include/ldebug.h + include/ldo.h + include/lfunc.h + include/lgc.h + include/llex.h + include/llimits.h + include/lmem.h + include/lobject.h + include/lopcodes.h + include/lparser.h + include/lstate.h + include/lstring.h + include/ltable.h + include/ltm.h + include/lua.h + include/luaconf.h + include/lualib.h + include/lundump.h + include/lvm.h + include/lzio.h ) -SET_SOURCE_FILES_PROPERTIES(${HDR_LIBLUA} PROPERTIES HEADER_FILE_ONLY TRUE) +set_source_files_properties(${HDR_LIBLUA} PROPERTIES HEADER_FILE_ONLY TRUE) include_directories(include) # Build Libraries -SET (SRC_LIBLUA -src/lapi.c -src/lauxlib.c -src/lbaselib.c -src/lbitlib.c -src/lcode.c -src/lcorolib.c -src/lctype.c -src/ldblib.c -src/ldebug.c -src/ldo.c -src/ldump.c -src/lfunc.c -src/lgc.c -src/linit.c -src/liolib.c -src/llex.c -src/lmathlib.c -src/lmem.c -src/loadlib.c -src/lobject.c -src/lopcodes.c -src/loslib.c -src/lparser.c -src/lstate.c -src/lstring.c -src/lstrlib.c -src/ltable.c -src/ltablib.c -src/ltm.c -src/lundump.c -src/lvm.c -src/lzio.c +set(SRC_LIBLUA + src/lapi.c + src/lauxlib.c + src/lbaselib.c + src/lbitlib.c + src/lcode.c + src/lcorolib.c + src/lctype.c + src/ldblib.c + src/ldebug.c + src/ldo.c + src/ldump.c + src/lfunc.c + src/lgc.c + src/linit.c + src/liolib.c + src/llex.c + src/lmathlib.c + src/lmem.c + src/loadlib.c + src/lobject.c + src/lopcodes.c + src/loslib.c + src/lparser.c + src/lstate.c + src/lstring.c + src/lstrlib.c + src/ltable.c + src/ltablib.c + src/ltm.c + src/lundump.c + src/lutf8lib.c + src/lvm.c + src/lzio.c ) # compile with C++ compiler set_source_files_properties(${SRC_LIBLUA} PROPERTIES LANGUAGE CXX) # append headers to sources to make them show up in MSVC GUI -LIST(APPEND SRC_LIBLUA ${HDR_LIBLUA}) - -ADD_LIBRARY ( lua SHARED ${SRC_LIBLUA} ) -TARGET_LINK_LIBRARIES ( lua ${LIBS}) +list(APPEND SRC_LIBLUA ${HDR_LIBLUA}) -install(TARGETS lua - LIBRARY DESTINATION ${DFHACK_LIBRARY_DESTINATION} - RUNTIME DESTINATION ${DFHACK_LIBRARY_DESTINATION}) +add_library(lua SHARED ${SRC_LIBLUA}) +set_target_properties(lua PROPERTIES OUTPUT_NAME lua53) +target_link_libraries(lua ${LIBS}) +target_include_directories(lua INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include) -IDE_FOLDER(lua "Depends") +if(MSVC) + # need no space to prevent /FI from being stripped: https://github.com/DFHack/dfhack/issues/1455 + target_compile_options(lua PRIVATE "/FIdfhack_llimits.h") +else() + target_compile_options(lua PRIVATE -include dfhack_llimits.h) + set_source_files_properties(src/lstring.c PROPERTIES COMPILE_FLAGS "-Wno-stringop-overflow") +endif() -#SET ( SRC_LUA src/lua.c ) -#SET ( SRC_LUAC src/luac.c src/print.c ) - -#ADD_EXECUTABLE ( lua ${SRC_LUA} ${LUA_RC_FILE}) -#ADD_EXECUTABLE ( luac ${SRC_LUAC} ${LUAC_RC_FILE}) -#TARGET_LINK_LIBRARIES ( lua liblua ) -#TARGET_LINK_LIBRARIES ( luac liblua_static ) +install(TARGETS lua + LIBRARY DESTINATION ${DFHACK_LIBRARY_DESTINATION} + RUNTIME DESTINATION ${DFHACK_LIBRARY_DESTINATION}) +ide_folder(lua "Depends") diff --git a/depends/lua/README b/depends/lua/README index afb121e552..83535f6ac7 100644 --- a/depends/lua/README +++ b/depends/lua/README @@ -1,37 +1,7 @@ -README for Lua 5.2 -See INSTALL for installation instructions. -See HISTORY for a summary of changes since the last released version. +This is Lua 5.3.6, released on 14 Sep 2020. -* What is Lua? - ------------ - Lua is a powerful, light-weight programming language designed for extending - applications. Lua is also frequently used as a general-purpose, stand-alone - language. Lua is free software. +For installation instructions, license details, and +further information about Lua, see +https://www.lua.org/manual/5.3/readme.html - For complete information, visit Lua's web site at http://www.lua.org/ . - For an executive summary, see http://www.lua.org/about.html . - - Lua has been used in many different projects around the world. - For a short list, see http://www.lua.org/uses.html . - -* Availability - ------------ - Lua is freely available for both academic and commercial purposes. - See COPYRIGHT and http://www.lua.org/license.html for details. - Lua can be downloaded at http://www.lua.org/download.html . - -* Installation - ------------ - Lua is implemented in pure ANSI C, and compiles unmodified in all known - platforms that have an ANSI C compiler. In most Unix-like platforms, simply - do "make" with a suitable target. See INSTALL for detailed instructions. - -* Origin - ------ - Lua is developed at Lua.org, a laboratory of the Department of Computer - Science of PUC-Rio (the Pontifical Catholic University of Rio de Janeiro - in Brazil). - For more information about the authors, see http://www.lua.org/authors.html . - -(end of README) diff --git a/depends/lua/include/dfhack_llimits.h b/depends/lua/include/dfhack_llimits.h new file mode 100644 index 0000000000..73aa52ef0b --- /dev/null +++ b/depends/lua/include/dfhack_llimits.h @@ -0,0 +1,72 @@ +/** +Copyright © 2018 Pauli + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and + must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source + distribution. + */ + +#pragma once + +#ifdef _MSC_VER +#include +#else +#include +#endif + +#include + +/*! \file dfhack_llimits.h + * dfhack specific lua porting header that overrides lua defaults for thread + * safety. + */ + +#ifdef _MSC_VER +typedef CRITICAL_SECTION mutex_t; +#else +typedef pthread_mutex_t mutex_t; +#endif + +struct lua_extra_state { + mutex_t* mutex; +}; + +#define luai_mutex(L) ((lua_extra_state*)lua_getextraspace(L))->mutex + +#ifdef _MSC_VER +#define luai_userstateopen(L) luai_mutex(L) = (mutex_t*)malloc(sizeof(mutex_t)); InitializeCriticalSection(luai_mutex(L)) +#define luai_userstateclose(L) lua_unlock(L); DeleteCriticalSection(luai_mutex(L)); free(luai_mutex(L)) +#define lua_lock(L) EnterCriticalSection(luai_mutex(L)) +#define lua_unlock(L) LeaveCriticalSection(luai_mutex(L)) +#else +#define luai_userstateopen(L) do { \ + luai_mutex(L) = (mutex_t*)malloc(sizeof(mutex_t)); \ + pthread_mutexattr_t attr; \ + pthread_mutexattr_init(&attr); \ + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); \ + pthread_mutex_init(luai_mutex(L), &attr); \ + pthread_mutexattr_destroy(&attr); \ + } while (0) +#define luai_userstateclose(L) do { \ + lua_unlock(L); \ + pthread_mutex_destroy(luai_mutex(L)); \ + free(luai_mutex(L)); \ + } while (0) +#define lua_lock(L) pthread_mutex_lock(luai_mutex(L)) +#define lua_unlock(L) pthread_mutex_unlock(luai_mutex(L)) +#endif diff --git a/depends/lua/include/lapi.h b/depends/lua/include/lapi.h index c7d34ad848..8e16ad53d9 100644 --- a/depends/lua/include/lapi.h +++ b/depends/lua/include/lapi.h @@ -1,5 +1,5 @@ /* -** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lapi.h,v 2.9.1.1 2017/04/19 17:20:42 roberto Exp $ ** Auxiliary functions from Lua API ** See Copyright Notice in lua.h */ diff --git a/depends/lua/include/lauxlib.h b/depends/lua/include/lauxlib.h index 0fb023b8e7..9857d3a835 100644 --- a/depends/lua/include/lauxlib.h +++ b/depends/lua/include/lauxlib.h @@ -1,5 +1,5 @@ /* -** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lauxlib.h,v 1.131.1.1 2017/04/19 17:20:42 roberto Exp $ ** Auxiliary functions for building Lua libraries ** See Copyright Notice in lua.h */ @@ -16,40 +16,48 @@ -/* extra error code for `luaL_load' */ +/* extra error code for 'luaL_loadfilex' */ #define LUA_ERRFILE (LUA_ERRERR+1) +/* key, in the registry, for table of loaded modules */ +#define LUA_LOADED_TABLE "_LOADED" + + +/* key, in the registry, for table of preloaded loaders */ +#define LUA_PRELOAD_TABLE "_PRELOAD" + + typedef struct luaL_Reg { const char *name; lua_CFunction func; } luaL_Reg; -LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver); -#define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM) +#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number)) + +LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz); +#define luaL_checkversion(L) \ + luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len); -LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg); -LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg, +LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg); +LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg, size_t *l); -LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg, +LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg, const char *def, size_t *l); -LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg); -LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def); +LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg); +LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def); -LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg); -LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg, +LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg); +LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg, lua_Integer def); -LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg); -LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg, - lua_Unsigned def); LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); -LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t); -LUALIB_API void (luaL_checkany) (lua_State *L, int narg); +LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t); +LUALIB_API void (luaL_checkany) (lua_State *L, int arg); LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname); @@ -59,13 +67,13 @@ LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); LUALIB_API void (luaL_where) (lua_State *L, int lvl); LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); -LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def, +LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def, const char *const lst[]); LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); LUALIB_API int (luaL_execresult) (lua_State *L, int stat); -/* pre-defined references */ +/* predefined references */ #define LUA_NOREF (-2) #define LUA_REFNIL (-1) @@ -83,7 +91,7 @@ LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); LUALIB_API lua_State *(luaL_newstate) (void); -LUALIB_API int (luaL_len) (lua_State *L, int idx); +LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx); LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p, const char *r); @@ -108,16 +116,13 @@ LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, #define luaL_newlibtable(L,l) \ lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) -#define luaL_newlib(L,l) (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) +#define luaL_newlib(L,l) \ + (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) -#define luaL_argcheck(L, cond,numarg,extramsg) \ - ((void)((cond) || luaL_argerror(L, (numarg), (extramsg)))) +#define luaL_argcheck(L, cond,arg,extramsg) \ + ((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) #define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) #define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) -#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) -#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) -#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) -#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) #define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) @@ -207,6 +212,53 @@ LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname, #endif +/* +** {================================================================== +** "Abstraction Layer" for basic report of messages and errors +** =================================================================== +*/ + +/* print a string */ +#if !defined(lua_writestring) +#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) +#endif + +/* print a newline and flush the output */ +#if !defined(lua_writeline) +#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) +#endif + +/* print an error message */ +#if !defined(lua_writestringerror) +#define lua_writestringerror(s,p) \ + (fprintf(stderr, (s), (p)), fflush(stderr)) +#endif + +/* }================================================================== */ + + +/* +** {============================================================ +** Compatibility with deprecated conversions +** ============================================================= +*/ +#if defined(LUA_COMPAT_APIINTCASTS) + +#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) +#define luaL_optunsigned(L,a,d) \ + ((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) + +#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) +#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) + +#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) +#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) + +#endif +/* }============================================================ */ + + + #endif diff --git a/depends/lua/include/lcode.h b/depends/lua/include/lcode.h index 6a1424cf5a..882dc9c156 100644 --- a/depends/lua/include/lcode.h +++ b/depends/lua/include/lcode.h @@ -1,5 +1,5 @@ /* -** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lcode.h,v 1.64.1.1 2017/04/19 17:20:42 roberto Exp $ ** Code generator for Lua ** See Copyright Notice in lua.h */ @@ -24,7 +24,11 @@ ** grep "ORDER OPR" if you change these enums (ORDER OP) */ typedef enum BinOpr { - OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW, + OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW, + OPR_DIV, + OPR_IDIV, + OPR_BAND, OPR_BOR, OPR_BXOR, + OPR_SHL, OPR_SHR, OPR_CONCAT, OPR_EQ, OPR_LT, OPR_LE, OPR_NE, OPR_GT, OPR_GE, @@ -33,10 +37,11 @@ typedef enum BinOpr { } BinOpr; -typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr; +typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr; -#define getcode(fs,e) ((fs)->f->code[(e)->u.info]) +/* get (pointer to) instruction of given 'expdesc' */ +#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) #define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx) @@ -52,7 +57,7 @@ LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n); LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n); LUAI_FUNC void luaK_checkstack (FuncState *fs, int n); LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s); -LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r); +LUAI_FUNC int luaK_intK (FuncState *fs, lua_Integer n); LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e); LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e); LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e); diff --git a/depends/lua/include/ldebug.h b/depends/lua/include/ldebug.h index 6445c763ea..8cea0ee0a7 100644 --- a/depends/lua/include/ldebug.h +++ b/depends/lua/include/ldebug.h @@ -1,5 +1,5 @@ /* -** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: ldebug.h,v 2.14.1.1 2017/04/19 17:20:42 roberto Exp $ ** Auxiliary functions from Debug Interface module ** See Copyright Notice in lua.h */ @@ -13,22 +13,27 @@ #define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1) -#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0) +#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : -1) #define resethookcount(L) (L->hookcount = L->basehookcount) -/* Active Lua function (given call info) */ -#define ci_func(ci) (clLvalue((ci)->func)) - LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *opname); -LUAI_FUNC l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2); -LUAI_FUNC l_noret luaG_aritherror (lua_State *L, const TValue *p1, +LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1, + const TValue *p2); +LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1, + const TValue *p2, + const char *msg); +LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2); LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2); LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...); +LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg, + TString *src, int line); LUAI_FUNC l_noret luaG_errormsg (lua_State *L); +LUAI_FUNC void luaG_traceexec (lua_State *L); + #endif diff --git a/depends/lua/include/ldo.h b/depends/lua/include/ldo.h index d3d3082c9b..3b2983a386 100644 --- a/depends/lua/include/ldo.h +++ b/depends/lua/include/ldo.h @@ -1,5 +1,5 @@ /* -** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: ldo.h,v 2.29.1.1 2017/04/19 17:20:42 roberto Exp $ ** Stack and Call structure of Lua ** See Copyright Notice in lua.h */ @@ -13,31 +13,43 @@ #include "lzio.h" -#define luaD_checkstack(L,n) if (L->stack_last - L->top <= (n)) \ - luaD_growstack(L, n); else condmovestack(L); +/* +** Macro to check stack size and grow stack if needed. Parameters +** 'pre'/'pos' allow the macro to preserve a pointer into the +** stack across reallocations, doing the work only when needed. +** 'condmovestack' is used in heavy tests to force a stack reallocation +** at every check. +*/ +#define luaD_checkstackaux(L,n,pre,pos) \ + if (L->stack_last - L->top <= (n)) \ + { pre; luaD_growstack(L, n); pos; } else { condmovestack(L,pre,pos); } + +/* In general, 'pre'/'pos' are empty (nothing to save) */ +#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) -#define incr_top(L) {L->top++; luaD_checkstack(L,0);} #define savestack(L,p) ((char *)(p) - (char *)L->stack) #define restorestack(L,n) ((TValue *)((char *)L->stack + (n))) -/* type of protected functions, to be ran by `runprotected' */ +/* type of protected functions, to be ran by 'runprotected' */ typedef void (*Pfunc) (lua_State *L, void *ud); LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name, const char *mode); LUAI_FUNC void luaD_hook (lua_State *L, int event, int line); LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults); -LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults, - int allowyield); +LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults); +LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults); LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u, ptrdiff_t oldtop, ptrdiff_t ef); -LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult); +LUAI_FUNC int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, + int nres); LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize); LUAI_FUNC void luaD_growstack (lua_State *L, int n); LUAI_FUNC void luaD_shrinkstack (lua_State *L); +LUAI_FUNC void luaD_inctop (lua_State *L); LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode); LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); diff --git a/depends/lua/include/lfunc.h b/depends/lua/include/lfunc.h index ca0d3a3e0b..c916e9878a 100644 --- a/depends/lua/include/lfunc.h +++ b/depends/lua/include/lfunc.h @@ -1,5 +1,5 @@ /* -** $Id: lfunc.h,v 2.8.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lfunc.h,v 2.15.1.1 2017/04/19 17:39:34 roberto Exp $ ** Auxiliary functions to manipulate prototypes and closures ** See Copyright Notice in lua.h */ @@ -18,14 +18,42 @@ cast(int, sizeof(TValue *)*((n)-1))) +/* test whether thread is in 'twups' list */ +#define isintwups(L) (L->twups != L) + + +/* +** maximum number of upvalues in a closure (both C and Lua). (Value +** must fit in a VM register.) +*/ +#define MAXUPVAL 255 + + +/* +** Upvalues for Lua closures +*/ +struct UpVal { + TValue *v; /* points to stack or to its own value */ + lu_mem refcount; /* reference counter */ + union { + struct { /* (when open) */ + UpVal *next; /* linked list */ + int touched; /* mark to avoid cycles with dead threads */ + } open; + TValue value; /* the value (when closed) */ + } u; +}; + +#define upisopen(up) ((up)->v != &(up)->u.value) + + LUAI_FUNC Proto *luaF_newproto (lua_State *L); -LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems); -LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems); -LUAI_FUNC UpVal *luaF_newupval (lua_State *L); +LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nelems); +LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nelems); +LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl); LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level); LUAI_FUNC void luaF_close (lua_State *L, StkId level); LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f); -LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv); LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number, int pc); diff --git a/depends/lua/include/lgc.h b/depends/lua/include/lgc.h index 84bb1cdf99..425cd7cef3 100644 --- a/depends/lua/include/lgc.h +++ b/depends/lua/include/lgc.h @@ -1,5 +1,5 @@ /* -** $Id: lgc.h,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lgc.h,v 2.91.1.1 2017/04/19 17:39:34 roberto Exp $ ** Garbage Collector ** See Copyright Notice in lua.h */ @@ -38,36 +38,27 @@ */ #define GCSpropagate 0 #define GCSatomic 1 -#define GCSsweepstring 2 -#define GCSsweepudata 3 -#define GCSsweep 4 -#define GCSpause 5 +#define GCSswpallgc 2 +#define GCSswpfinobj 3 +#define GCSswptobefnz 4 +#define GCSswpend 5 +#define GCScallfin 6 +#define GCSpause 7 #define issweepphase(g) \ - (GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep) + (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) -#define isgenerational(g) ((g)->gckind == KGC_GEN) /* -** macros to tell when main invariant (white objects cannot point to black -** ones) must be kept. During a non-generational collection, the sweep +** macro to tell when main invariant (white objects cannot point to black +** ones) must be kept. During a collection, the sweep ** phase may break the invariant, as objects turned white may point to ** still-black objects. The invariant is restored when sweep ends and -** all objects are white again. During a generational collection, the -** invariant must be kept all times. +** all objects are white again. */ -#define keepinvariant(g) (isgenerational(g) || g->gcstate <= GCSatomic) - - -/* -** Outside the collector, the state in generational mode is kept in -** 'propagate', so 'keepinvariant' is always true. -*/ -#define keepinvariantout(g) \ - check_exp(g->gcstate == GCSpropagate || !isgenerational(g), \ - g->gcstate <= GCSatomic) +#define keepinvariant(g) ((g)->gcstate <= GCSatomic) /* @@ -83,75 +74,74 @@ #define testbit(x,b) testbits(x, bitmask(b)) -/* Layout for bit use in `marked' field: */ +/* Layout for bit use in 'marked' field: */ #define WHITE0BIT 0 /* object is white (type 0) */ #define WHITE1BIT 1 /* object is white (type 1) */ #define BLACKBIT 2 /* object is black */ -#define FINALIZEDBIT 3 /* object has been separated for finalization */ -#define SEPARATED 4 /* object is in 'finobj' list or in 'tobefnz' */ -#define FIXEDBIT 5 /* object is fixed (should not be collected) */ -#define OLDBIT 6 /* object is old (only in generational mode) */ +#define FINALIZEDBIT 3 /* object has been marked for finalization */ /* bit 7 is currently used by tests (luaL_checkmemory) */ #define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) -#define iswhite(x) testbits((x)->gch.marked, WHITEBITS) -#define isblack(x) testbit((x)->gch.marked, BLACKBIT) +#define iswhite(x) testbits((x)->marked, WHITEBITS) +#define isblack(x) testbit((x)->marked, BLACKBIT) #define isgray(x) /* neither white nor black */ \ - (!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT))) - -#define isold(x) testbit((x)->gch.marked, OLDBIT) + (!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT))) -/* MOVE OLD rule: whenever an object is moved to the beginning of - a GC list, its old bit must be cleared */ -#define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT) +#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT) -#define otherwhite(g) (g->currentwhite ^ WHITEBITS) +#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS) #define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow))) -#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked) +#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked) -#define changewhite(x) ((x)->gch.marked ^= WHITEBITS) -#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT) - -#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) +#define changewhite(x) ((x)->marked ^= WHITEBITS) +#define gray2black(x) l_setbit((x)->marked, BLACKBIT) #define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS) -#define luaC_condGC(L,c) \ - {if (G(L)->GCdebt > 0) {c;}; condchangemem(L);} -#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);) +/* +** Does one step of collection when debt becomes positive. 'pre'/'pos' +** allows some adjustments to be done only when needed. macro +** 'condchangemem' is used only for heavy tests (forcing a full +** GC cycle on every opportunity) +*/ +#define luaC_condGC(L,pre,pos) \ + { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ + condchangemem(L,pre,pos); } +/* more often than not, 'pre'/'pos' are empty */ +#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) -#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ - luaC_barrier_(L,obj2gco(p),gcvalue(v)); } -#define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ - luaC_barrierback_(L,p); } +#define luaC_barrier(L,p,v) ( \ + (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \ + luaC_barrier_(L,obj2gco(p),gcvalue(v)) : cast_void(0)) -#define luaC_objbarrier(L,p,o) \ - { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \ - luaC_barrier_(L,obj2gco(p),obj2gco(o)); } +#define luaC_barrierback(L,p,v) ( \ + (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \ + luaC_barrierback_(L,p) : cast_void(0)) -#define luaC_objbarrierback(L,p,o) \ - { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); } +#define luaC_objbarrier(L,p,o) ( \ + (isblack(p) && iswhite(o)) ? \ + luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) -#define luaC_barrierproto(L,p,c) \ - { if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); } +#define luaC_upvalbarrier(L,uv) ( \ + (iscollectable((uv)->v) && !upisopen(uv)) ? \ + luaC_upvalbarrier_(L,uv) : cast_void(0)) +LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o); LUAI_FUNC void luaC_freeallobjects (lua_State *L); LUAI_FUNC void luaC_step (lua_State *L); -LUAI_FUNC void luaC_forcestep (lua_State *L); LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask); LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency); -LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, - GCObject **list, int offset); +LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz); LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v); -LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o); -LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c); +LUAI_FUNC void luaC_barrierback_ (lua_State *L, Table *o); +LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, UpVal *uv); LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt); -LUAI_FUNC void luaC_checkupvalcolor (global_State *g, UpVal *uv); -LUAI_FUNC void luaC_changemode (lua_State *L, int mode); +LUAI_FUNC void luaC_upvdeccount (lua_State *L, UpVal *uv); + #endif diff --git a/depends/lua/include/llex.h b/depends/lua/include/llex.h index a4acdd3021..2ed0af66a4 100644 --- a/depends/lua/include/llex.h +++ b/depends/lua/include/llex.h @@ -1,5 +1,5 @@ /* -** $Id: llex.h,v 1.72.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: llex.h,v 1.79.1.1 2017/04/19 17:20:42 roberto Exp $ ** Lexical Analyzer ** See Copyright Notice in lua.h */ @@ -14,6 +14,10 @@ #define FIRST_RESERVED 257 +#if !defined(LUA_ENV) +#define LUA_ENV "_ENV" +#endif + /* * WARNING: if you change the order of this enumeration, @@ -26,8 +30,10 @@ enum RESERVED { TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT, TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE, /* other terminal symbols */ - TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_DBCOLON, TK_EOS, - TK_NUMBER, TK_NAME, TK_STRING + TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, + TK_SHL, TK_SHR, + TK_DBCOLON, TK_EOS, + TK_FLT, TK_INT, TK_NAME, TK_STRING }; /* number of reserved words */ @@ -36,6 +42,7 @@ enum RESERVED { typedef union { lua_Number r; + lua_Integer i; TString *ts; } SemInfo; /* semantics information */ @@ -51,17 +58,17 @@ typedef struct Token { typedef struct LexState { int current; /* current character (charint) */ int linenumber; /* input line counter */ - int lastline; /* line of last token `consumed' */ + int lastline; /* line of last token 'consumed' */ Token t; /* current token */ Token lookahead; /* look ahead token */ struct FuncState *fs; /* current function (parser) */ struct lua_State *L; ZIO *z; /* input stream */ Mbuffer *buff; /* buffer for tokens */ + Table *h; /* to avoid collection/reuse strings */ struct Dyndata *dyd; /* dynamic structures used by the parser */ TString *source; /* current source name */ TString *envn; /* environment variable name */ - char decpoint; /* locale decimal point */ } LexState; diff --git a/depends/lua/include/llimits.h b/depends/lua/include/llimits.h index 152dd05515..d1036f6bc8 100644 --- a/depends/lua/include/llimits.h +++ b/depends/lua/include/llimits.h @@ -1,6 +1,6 @@ /* -** $Id: llimits.h,v 1.103.1.1 2013/04/12 18:48:47 roberto Exp $ -** Limits, basic types, and some other `installation-dependent' definitions +** $Id: llimits.h,v 1.141.1.1 2017/04/19 17:20:42 roberto Exp $ +** Limits, basic types, and some other 'installation-dependent' definitions ** See Copyright Notice in lua.h */ @@ -14,54 +14,77 @@ #include "lua.h" - -typedef unsigned LUA_INT32 lu_int32; - +/* +** 'lu_mem' and 'l_mem' are unsigned/signed integers big enough to count +** the total memory used by Lua (in bytes). Usually, 'size_t' and +** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines. +*/ +#if defined(LUAI_MEM) /* { external definitions? */ typedef LUAI_UMEM lu_mem; - typedef LUAI_MEM l_mem; +#elif LUAI_BITSINT >= 32 /* }{ */ +typedef size_t lu_mem; +typedef ptrdiff_t l_mem; +#else /* 16-bit ints */ /* }{ */ +typedef unsigned long lu_mem; +typedef long l_mem; +#endif /* } */ - -/* chars used as small naturals (so that `char' is reserved for characters) */ +/* chars used as small naturals (so that 'char' is reserved for characters) */ typedef unsigned char lu_byte; -#define MAX_SIZET ((size_t)(~(size_t)0)-2) +/* maximum value for size_t */ +#define MAX_SIZET ((size_t)(~(size_t)0)) + +/* maximum size visible for Lua (must be representable in a lua_Integer */ +#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \ + : (size_t)(LUA_MAXINTEGER)) + -#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2) +#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) -#define MAX_LMEM ((l_mem) ((MAX_LUMEM >> 1) - 2)) +#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) -#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */ +#define MAX_INT INT_MAX /* maximum value of an int */ + /* -** conversion of pointer to integer +** conversion of pointer to unsigned integer: ** this is for hashing only; there is no problem if the integer ** cannot hold the whole pointer value */ -#define IntPoint(p) ((unsigned int)(lu_mem)(p)) +#define point2uint(p) ((unsigned int)((size_t)(p) & UINT_MAX)) /* type to ensure maximum alignment */ -#if !defined(LUAI_USER_ALIGNMENT_T) -#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; } +#if defined(LUAI_USER_ALIGNMENT_T) +typedef LUAI_USER_ALIGNMENT_T L_Umaxalign; +#else +typedef union { + lua_Number n; + double u; + void *s; + lua_Integer i; + long l; +} L_Umaxalign; #endif -typedef LUAI_USER_ALIGNMENT_T L_Umaxalign; -/* result of a `usual argument conversion' over lua_Number */ +/* types of 'usual argument conversions' for lua_Number and lua_Integer */ typedef LUAI_UACNUMBER l_uacNumber; +typedef LUAI_UACINT l_uacInt; /* internal assertions for in-house debugging */ #if defined(lua_assert) #define check_exp(c,e) (lua_assert(c), (e)) /* to avoid problems with conditions too long */ -#define lua_longassert(c) { if (!(c)) lua_assert(0); } +#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) #else #define lua_assert(c) ((void)0) #define check_exp(c,e) (e) @@ -72,38 +95,49 @@ typedef LUAI_UACNUMBER l_uacNumber; ** assertion for checking API calls */ #if !defined(luai_apicheck) - -#if defined(LUA_USE_APICHECK) -#include -#define luai_apicheck(L,e) assert(e) -#else -#define luai_apicheck(L,e) lua_assert(e) -#endif - +#define luai_apicheck(l,e) lua_assert(e) #endif #define api_check(l,e,msg) luai_apicheck(l,(e) && msg) +/* macro to avoid warnings about unused variables */ #if !defined(UNUSED) -#define UNUSED(x) ((void)(x)) /* to avoid warnings */ +#define UNUSED(x) ((void)(x)) #endif +/* type casts (a macro highlights casts in the code) */ #define cast(t, exp) ((t)(exp)) +#define cast_void(i) cast(void, (i)) #define cast_byte(i) cast(lu_byte, (i)) #define cast_num(i) cast(lua_Number, (i)) #define cast_int(i) cast(int, (i)) #define cast_uchar(i) cast(unsigned char, (i)) +/* cast a signed lua_Integer to lua_Unsigned */ +#if !defined(l_castS2U) +#define l_castS2U(i) ((lua_Unsigned)(i)) +#endif + +/* +** cast a lua_Unsigned to a signed lua_Integer; this cast is +** not strict ISO C, but two-complement architectures should +** work fine. +*/ +#if !defined(l_castU2S) +#define l_castU2S(i) ((lua_Integer)(i)) +#endif + + /* ** non-return type */ #if defined(__GNUC__) #define l_noret void __attribute__((noreturn)) -#elif defined(_MSC_VER) +#elif defined(_MSC_VER) && _MSC_VER >= 1200 #define l_noret void __declspec(noreturn) #else #define l_noret void @@ -119,29 +153,50 @@ typedef LUAI_UACNUMBER l_uacNumber; #define LUAI_MAXCCALLS 200 #endif -/* -** maximum number of upvalues in a closure (both C and Lua). (Value -** must fit in an unsigned char.) -*/ -#define MAXUPVAL UCHAR_MAX /* -** type for virtual-machine instructions +** type for virtual-machine instructions; ** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h) */ -typedef lu_int32 Instruction; - +#if LUAI_BITSINT >= 32 +typedef unsigned int Instruction; +#else +typedef unsigned long Instruction; +#endif -/* maximum stack for a Lua function */ -#define MAXSTACK 250 +/* +** Maximum length for short strings, that is, strings that are +** internalized. (Cannot be smaller than reserved words or tags for +** metamethods, as these strings must be internalized; +** #("function") = 8, #("__newindex") = 10.) +*/ +#if !defined(LUAI_MAXSHORTLEN) +#define LUAI_MAXSHORTLEN 40 +#endif -/* minimum size for the string table (must be power of 2) */ +/* +** Initial size for the string table (must be power of 2). +** The Lua core alone registers ~50 strings (reserved words + +** metaevent keys + a few others). Libraries would typically add +** a few dozens more. +*/ #if !defined(MINSTRTABSIZE) -#define MINSTRTABSIZE 32 +#define MINSTRTABSIZE 128 +#endif + + +/* +** Size of cache for strings in the API. 'N' is the number of +** sets (better be a prime) and "M" is the size of each set (M == 1 +** makes a direct cache.) +*/ +#if !defined(STRCACHE_N) +#define STRCACHE_N 53 +#define STRCACHE_M 2 #endif @@ -151,13 +206,21 @@ typedef lu_int32 Instruction; #endif +/* +** macros that are executed whenever program enters the Lua core +** ('lua_lock') and leaves the core ('lua_unlock') +*/ #if !defined(lua_lock) -#define lua_lock(L) ((void) 0) -#define lua_unlock(L) ((void) 0) +#define lua_lock(L) ((void) 0) +#define lua_unlock(L) ((void) 0) #endif +/* +** macro executed during Lua functions at points where the +** function can yield. +*/ #if !defined(luai_threadyield) -#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} +#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} #endif @@ -183,127 +246,78 @@ typedef lu_int32 Instruction; #endif #if !defined(luai_userstateresume) -#define luai_userstateresume(L,n) ((void)L) +#define luai_userstateresume(L,n) ((void)L) #endif #if !defined(luai_userstateyield) -#define luai_userstateyield(L,n) ((void)L) +#define luai_userstateyield(L,n) ((void)L) #endif -/* -** lua_number2int is a macro to convert lua_Number to int. -** lua_number2integer is a macro to convert lua_Number to lua_Integer. -** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned. -** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number. -** luai_hashnum is a macro to hash a lua_Number value into an integer. -** The hash must be deterministic and give reasonable values for -** both small and large values (outside the range of integers). -*/ - -#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK) /* { */ -/* trick with Microsoft assembler for X86 */ - -#define lua_number2int(i,n) __asm {__asm fld n __asm fistp i} -#define lua_number2integer(i,n) lua_number2int(i, n) -#define lua_number2unsigned(i,n) \ - {__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;} - - -#elif defined(LUA_IEEE754TRICK) /* }{ */ -/* the next trick should work on any machine using IEEE754 with - a 32-bit int type */ - -union luai_Cast { double l_d; LUA_INT32 l_p[2]; }; - -#if !defined(LUA_IEEEENDIAN) /* { */ -#define LUAI_EXTRAIEEE \ - static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)}; -#define LUA_IEEEENDIANLOC (ieeeendian.l_p[1] == 33) -#else -#define LUA_IEEEENDIANLOC LUA_IEEEENDIAN -#define LUAI_EXTRAIEEE /* empty */ -#endif /* } */ -#define lua_number2int32(i,n,t) \ - { LUAI_EXTRAIEEE \ - volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \ - (i) = (t)u.l_p[LUA_IEEEENDIANLOC]; } -#define luai_hashnum(i,n) \ - { volatile union luai_Cast u; u.l_d = (n) + 1.0; /* avoid -0 */ \ - (i) = u.l_p[0]; (i) += u.l_p[1]; } /* add double bits for his hash */ - -#define lua_number2int(i,n) lua_number2int32(i, n, int) -#define lua_number2unsigned(i,n) lua_number2int32(i, n, lua_Unsigned) +/* +** The luai_num* macros define the primitive operations over numbers. +*/ -/* the trick can be expanded to lua_Integer when it is a 32-bit value */ -#if defined(LUA_IEEELL) -#define lua_number2integer(i,n) lua_number2int32(i, n, lua_Integer) +/* floor division (defined as 'floor(a/b)') */ +#if !defined(luai_numidiv) +#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b))) #endif -#endif /* } */ - - -/* the following definitions always work, but may be slow */ - -#if !defined(lua_number2int) -#define lua_number2int(i,n) ((i)=(int)(n)) +/* float division */ +#if !defined(luai_numdiv) +#define luai_numdiv(L,a,b) ((a)/(b)) #endif -#if !defined(lua_number2integer) -#define lua_number2integer(i,n) ((i)=(lua_Integer)(n)) +/* +** modulo: defined as 'a - floor(a/b)*b'; this definition gives NaN when +** 'b' is huge, but the result should be 'a'. 'fmod' gives the result of +** 'a - trunc(a/b)*b', and therefore must be corrected when 'trunc(a/b) +** ~= floor(a/b)'. That happens when the division has a non-integer +** negative result, which is equivalent to the test below. +*/ +#if !defined(luai_nummod) +#define luai_nummod(L,a,b,m) \ + { (m) = l_mathop(fmod)(a,b); if ((m)*(b) < 0) (m) += (b); } #endif -#if !defined(lua_number2unsigned) /* { */ -/* the following definition assures proper modulo behavior */ -#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT) -#include -#define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1) -#define lua_number2unsigned(i,n) \ - ((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED)) -#else -#define lua_number2unsigned(i,n) ((i)=(lua_Unsigned)(n)) +/* exponentiation */ +#if !defined(luai_numpow) +#define luai_numpow(L,a,b) ((void)L, l_mathop(pow)(a,b)) #endif -#endif /* } */ - -#if !defined(lua_unsigned2number) -/* on several machines, coercion from unsigned to double is slow, - so it may be worth to avoid */ -#define lua_unsigned2number(u) \ - (((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u)) +/* the others are quite standard operations */ +#if !defined(luai_numadd) +#define luai_numadd(L,a,b) ((a)+(b)) +#define luai_numsub(L,a,b) ((a)-(b)) +#define luai_nummul(L,a,b) ((a)*(b)) +#define luai_numunm(L,a) (-(a)) +#define luai_numeq(a,b) ((a)==(b)) +#define luai_numlt(a,b) ((a)<(b)) +#define luai_numle(a,b) ((a)<=(b)) +#define luai_numisnan(a) (!luai_numeq((a), (a))) #endif -#if defined(ltable_c) && !defined(luai_hashnum) - -#include -#include - -#define luai_hashnum(i,n) { int e; \ - n = l_mathop(frexp)(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP); \ - lua_number2int(i, n); i += e; } - -#endif - /* ** macro to control inclusion of some hard tests on stack reallocation */ #if !defined(HARDSTACKTESTS) -#define condmovestack(L) ((void)0) +#define condmovestack(L,pre,pos) ((void)0) #else /* realloc stack keeping its size */ -#define condmovestack(L) luaD_reallocstack((L), (L)->stacksize) +#define condmovestack(L,pre,pos) \ + { int sz_ = (L)->stacksize; pre; luaD_reallocstack((L), sz_); pos; } #endif #if !defined(HARDMEMTESTS) -#define condchangemem(L) condmovestack(L) +#define condchangemem(L,pre,pos) ((void)0) #else -#define condchangemem(L) \ - ((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1))) +#define condchangemem(L,pre,pos) \ + { if (G(L)->gcrunning) { pre; luaC_fullgc(L, 0); pos; } } #endif #endif diff --git a/depends/lua/include/lmem.h b/depends/lua/include/lmem.h index bd4f4e0726..357b1e43e7 100644 --- a/depends/lua/include/lmem.h +++ b/depends/lua/include/lmem.h @@ -1,5 +1,5 @@ /* -** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lmem.h,v 1.43.1.1 2017/04/19 17:20:42 roberto Exp $ ** Interface to Memory Manager ** See Copyright Notice in lua.h */ @@ -15,20 +15,32 @@ /* -** This macro avoids the runtime division MAX_SIZET/(e), as 'e' is -** always constant. -** The macro is somewhat complex to avoid warnings: -** +1 avoids warnings of "comparison has constant result"; -** cast to 'void' avoids warnings of "value unused". +** This macro reallocs a vector 'b' from 'on' to 'n' elements, where +** each element has size 'e'. In case of arithmetic overflow of the +** product 'n'*'e', it raises an error (calling 'luaM_toobig'). Because +** 'e' is always constant, it avoids the runtime division MAX_SIZET/(e). +** +** (The macro is somewhat complex to avoid warnings: The 'sizeof' +** comparison avoids a runtime comparison when overflow cannot occur. +** The compiler should be able to optimize the real test by itself, but +** when it does it, it may give a warning about "comparison is always +** false due to limited range of data type"; the +1 tricks the compiler, +** avoiding this warning but also this optimization.) */ #define luaM_reallocv(L,b,on,n,e) \ - (cast(void, \ - (cast(size_t, (n)+1) > MAX_SIZET/(e)) ? (luaM_toobig(L), 0) : 0), \ + (((sizeof(n) >= sizeof(size_t) && cast(size_t, (n)) + 1 > MAX_SIZET/(e)) \ + ? luaM_toobig(L) : cast_void(0)) , \ luaM_realloc_(L, (b), (on)*(e), (n)*(e))) +/* +** Arrays of chars do not need any test +*/ +#define luaM_reallocvchar(L,b,on,n) \ + cast(char *, luaM_realloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) + #define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0) #define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0) -#define luaM_freearray(L, b, n) luaM_reallocv(L, (b), n, 0, sizeof((b)[0])) +#define luaM_freearray(L, b, n) luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0) #define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s)) #define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t))) diff --git a/depends/lua/include/lobject.h b/depends/lua/include/lobject.h index 3a630b944c..2408861402 100644 --- a/depends/lua/include/lobject.h +++ b/depends/lua/include/lobject.h @@ -1,5 +1,5 @@ /* -** $Id: lobject.h,v 2.71.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lobject.h,v 2.117.1.1 2017/04/19 17:39:34 roberto Exp $ ** Type definitions for Lua objects ** See Copyright Notice in lua.h */ @@ -19,14 +19,13 @@ /* ** Extra tags for non-values */ -#define LUA_TPROTO LUA_NUMTAGS -#define LUA_TUPVAL (LUA_NUMTAGS+1) -#define LUA_TDEADKEY (LUA_NUMTAGS+2) +#define LUA_TPROTO LUA_NUMTAGS /* function prototypes */ +#define LUA_TDEADKEY (LUA_NUMTAGS+1) /* removed keys in tables */ /* ** number of all possible tags (including LUA_TNONE but excluding DEADKEY) */ -#define LUA_TOTALTAGS (LUA_TUPVAL+2) +#define LUA_TOTALTAGS (LUA_TPROTO + 2) /* @@ -36,8 +35,6 @@ ** bit 6: whether value is collectable */ -#define VARBITS (3 << 4) - /* ** LUA_TFUNCTION variants: @@ -57,6 +54,11 @@ #define LUA_TLNGSTR (LUA_TSTRING | (1 << 4)) /* long strings */ +/* Variant tags for numbers */ +#define LUA_TNUMFLT (LUA_TNUMBER | (0 << 4)) /* float numbers */ +#define LUA_TNUMINT (LUA_TNUMBER | (1 << 4)) /* integer numbers */ + + /* Bit mark for collectable types */ #define BIT_ISCOLLECTABLE (1 << 6) @@ -65,9 +67,9 @@ /* -** Union of all collectable objects +** Common type for all collectable objects */ -typedef union GCObject GCObject; +typedef struct GCObject GCObject; /* @@ -78,21 +80,12 @@ typedef union GCObject GCObject; /* -** Common header in struct form +** Common type has only the common header */ -typedef struct GCheader { +struct GCObject { CommonHeader; -} GCheader; - - - -/* -** Union of all Lua values -*/ -typedef union Value Value; - +}; -#define numfield lua_Number n; /* numbers */ @@ -101,9 +94,26 @@ typedef union Value Value; ** an actual value plus a tag with its type. */ +/* +** Union of all Lua values +*/ +typedef union Value { + GCObject *gc; /* collectable objects */ + void *p; /* light userdata */ + int b; /* booleans */ + lua_CFunction f; /* light C functions */ + lua_Integer i; /* integer numbers */ + lua_Number n; /* float numbers */ +} Value; + + #define TValuefields Value value_; int tt_ -typedef struct lua_TValue TValue; + +typedef struct lua_TValue { + TValuefields; +} TValue; + /* macro defining a nil value */ @@ -111,7 +121,6 @@ typedef struct lua_TValue TValue; #define val_(o) ((o)->value_) -#define num_(o) (val_(o).n) /* raw type tag of a TValue */ @@ -124,13 +133,15 @@ typedef struct lua_TValue TValue; #define ttype(o) (rttype(o) & 0x3F) /* type tag of a TValue with no variants (bits 0-3) */ -#define ttypenv(o) (novariant(rttype(o))) +#define ttnov(o) (novariant(rttype(o))) /* Macros to test type */ #define checktag(o,t) (rttype(o) == (t)) -#define checktype(o,t) (ttypenv(o) == (t)) -#define ttisnumber(o) checktag((o), LUA_TNUMBER) +#define checktype(o,t) (ttnov(o) == (t)) +#define ttisnumber(o) checktype((o), LUA_TNUMBER) +#define ttisfloat(o) checktag((o), LUA_TNUMFLT) +#define ttisinteger(o) checktag((o), LUA_TNUMINT) #define ttisnil(o) checktag((o), LUA_TNIL) #define ttisboolean(o) checktag((o), LUA_TBOOLEAN) #define ttislightuserdata(o) checktag((o), LUA_TLIGHTUSERDATA) @@ -143,27 +154,27 @@ typedef struct lua_TValue TValue; #define ttisCclosure(o) checktag((o), ctb(LUA_TCCL)) #define ttisLclosure(o) checktag((o), ctb(LUA_TLCL)) #define ttislcf(o) checktag((o), LUA_TLCF) -#define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA)) +#define ttisfulluserdata(o) checktag((o), ctb(LUA_TUSERDATA)) #define ttisthread(o) checktag((o), ctb(LUA_TTHREAD)) #define ttisdeadkey(o) checktag((o), LUA_TDEADKEY) -#define ttisequal(o1,o2) (rttype(o1) == rttype(o2)) /* Macros to access values */ -#define nvalue(o) check_exp(ttisnumber(o), num_(o)) +#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) +#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) +#define nvalue(o) check_exp(ttisnumber(o), \ + (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) #define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) #define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) -#define rawtsvalue(o) check_exp(ttisstring(o), &val_(o).gc->ts) -#define tsvalue(o) (&rawtsvalue(o)->tsv) -#define rawuvalue(o) check_exp(ttisuserdata(o), &val_(o).gc->u) -#define uvalue(o) (&rawuvalue(o)->uv) -#define clvalue(o) check_exp(ttisclosure(o), &val_(o).gc->cl) -#define clLvalue(o) check_exp(ttisLclosure(o), &val_(o).gc->cl.l) -#define clCvalue(o) check_exp(ttisCclosure(o), &val_(o).gc->cl.c) +#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) +#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) +#define clvalue(o) check_exp(ttisclosure(o), gco2cl(val_(o).gc)) +#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) +#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) #define fvalue(o) check_exp(ttislcf(o), val_(o).f) -#define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h) +#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) #define bvalue(o) check_exp(ttisboolean(o), val_(o).b) -#define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th) +#define thvalue(o) check_exp(ttisthread(o), gco2th(val_(o).gc)) /* a dead value may get the 'gc' field, but cannot access its contents */ #define deadvalue(o) check_exp(ttisdeadkey(o), cast(void *, val_(o).gc)) @@ -174,18 +185,27 @@ typedef struct lua_TValue TValue; /* Macros for internal tests */ -#define righttt(obj) (ttype(obj) == gcvalue(obj)->gch.tt) +#define righttt(obj) (ttype(obj) == gcvalue(obj)->tt) -#define checkliveness(g,obj) \ +#define checkliveness(L,obj) \ lua_longassert(!iscollectable(obj) || \ - (righttt(obj) && !isdead(g,gcvalue(obj)))) + (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj))))) /* Macros to set values */ #define settt_(o,t) ((o)->tt_=(t)) -#define setnvalue(obj,x) \ - { TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); } +#define setfltvalue(obj,x) \ + { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_TNUMFLT); } + +#define chgfltvalue(obj,x) \ + { TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); } + +#define setivalue(obj,x) \ + { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_TNUMINT); } + +#define chgivalue(obj,x) \ + { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } #define setnilvalue(obj) settt_(obj, LUA_TNIL) @@ -199,48 +219,46 @@ typedef struct lua_TValue TValue; { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); } #define setgcovalue(L,obj,x) \ - { TValue *io=(obj); GCObject *i_g=(x); \ - val_(io).gc=i_g; settt_(io, ctb(gch(i_g)->tt)); } + { TValue *io = (obj); GCObject *i_g=(x); \ + val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } #define setsvalue(L,obj,x) \ - { TValue *io=(obj); \ - TString *x_ = (x); \ - val_(io).gc=cast(GCObject *, x_); settt_(io, ctb(x_->tsv.tt)); \ - checkliveness(G(L),io); } + { TValue *io = (obj); TString *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ + checkliveness(L,io); } #define setuvalue(L,obj,x) \ - { TValue *io=(obj); \ - val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TUSERDATA)); \ - checkliveness(G(L),io); } + { TValue *io = (obj); Udata *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TUSERDATA)); \ + checkliveness(L,io); } #define setthvalue(L,obj,x) \ - { TValue *io=(obj); \ - val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTHREAD)); \ - checkliveness(G(L),io); } + { TValue *io = (obj); lua_State *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTHREAD)); \ + checkliveness(L,io); } #define setclLvalue(L,obj,x) \ - { TValue *io=(obj); \ - val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TLCL)); \ - checkliveness(G(L),io); } + { TValue *io = (obj); LClosure *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TLCL)); \ + checkliveness(L,io); } #define setclCvalue(L,obj,x) \ - { TValue *io=(obj); \ - val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TCCL)); \ - checkliveness(G(L),io); } + { TValue *io = (obj); CClosure *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TCCL)); \ + checkliveness(L,io); } #define sethvalue(L,obj,x) \ - { TValue *io=(obj); \ - val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \ - checkliveness(G(L),io); } + { TValue *io = (obj); Table *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTABLE)); \ + checkliveness(L,io); } #define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY) #define setobj(L,obj1,obj2) \ - { const TValue *io2=(obj2); TValue *io1=(obj1); \ - io1->value_ = io2->value_; io1->tt_ = io2->tt_; \ - checkliveness(G(L),io1); } + { TValue *io1=(obj1); *io1 = *(obj2); \ + (void)L; checkliveness(L,io1); } /* @@ -256,188 +274,110 @@ typedef struct lua_TValue TValue; #define setptvalue2s setptvalue /* from table to same table */ #define setobjt2t setobj -/* to table */ -#define setobj2t setobj /* to new object */ #define setobj2n setobj #define setsvalue2n setsvalue +/* to table (define it as an expression to be used in macros) */ +#define setobj2t(L,o1,o2) ((void)L, *(o1)=*(o2), checkliveness(L,(o1))) + -/* check whether a number is valid (useful only for NaN trick) */ -#define luai_checknum(L,o,c) { /* empty */ } /* ** {====================================================== -** NaN Trick +** types and prototypes ** ======================================================= */ -#if defined(LUA_NANTRICK) -/* -** numbers are represented in the 'd_' field. All other values have the -** value (NNMARK | tag) in 'tt__'. A number with such pattern would be -** a "signaled NaN", which is never generated by regular operations by -** the CPU (nor by 'strtod') -*/ -/* allows for external implementation for part of the trick */ -#if !defined(NNMARK) /* { */ - - -#if !defined(LUA_IEEEENDIAN) -#error option 'LUA_NANTRICK' needs 'LUA_IEEEENDIAN' -#endif - - -#define NNMARK 0x7FF7A500 -#define NNMASK 0x7FFFFF00 - -#undef TValuefields -#undef NILCONSTANT - -#if (LUA_IEEEENDIAN == 0) /* { */ - -/* little endian */ -#define TValuefields \ - union { struct { Value v__; int tt__; } i; double d__; } u -#define NILCONSTANT {{{NULL}, tag2tt(LUA_TNIL)}} -/* field-access macros */ -#define v_(o) ((o)->u.i.v__) -#define d_(o) ((o)->u.d__) -#define tt_(o) ((o)->u.i.tt__) - -#else /* }{ */ - -/* big endian */ -#define TValuefields \ - union { struct { int tt__; Value v__; } i; double d__; } u -#define NILCONSTANT {{tag2tt(LUA_TNIL), {NULL}}} -/* field-access macros */ -#define v_(o) ((o)->u.i.v__) -#define d_(o) ((o)->u.d__) -#define tt_(o) ((o)->u.i.tt__) - -#endif /* } */ - -#endif /* } */ - - -/* correspondence with standard representation */ -#undef val_ -#define val_(o) v_(o) -#undef num_ -#define num_(o) d_(o) - - -#undef numfield -#define numfield /* no such field; numbers are the entire struct */ - -/* basic check to distinguish numbers from non-numbers */ -#undef ttisnumber -#define ttisnumber(o) ((tt_(o) & NNMASK) != NNMARK) - -#define tag2tt(t) (NNMARK | (t)) - -#undef rttype -#define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff) - -#undef settt_ -#define settt_(o,t) (tt_(o) = tag2tt(t)) +typedef TValue *StkId; /* index to stack elements */ -#undef setnvalue -#define setnvalue(obj,x) \ - { TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); } -#undef setobj -#define setobj(L,obj1,obj2) \ - { const TValue *o2_=(obj2); TValue *o1_=(obj1); \ - o1_->u = o2_->u; \ - checkliveness(G(L),o1_); } /* -** these redefinitions are not mandatory, but these forms are more efficient +** Header for string value; string bytes follow the end of this structure +** (aligned according to 'UTString'; see next). */ - -#undef checktag -#undef checktype -#define checktag(o,t) (tt_(o) == tag2tt(t)) -#define checktype(o,t) (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS)) - -#undef ttisequal -#define ttisequal(o1,o2) \ - (ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2))) - - -#undef luai_checknum -#define luai_checknum(L,o,c) { if (!ttisnumber(o)) c; } - -#endif -/* }====================================================== */ - +typedef struct TString { + CommonHeader; + lu_byte extra; /* reserved words for short strings; "has hash" for longs */ + lu_byte shrlen; /* length for short strings */ + unsigned int hash; + union { + size_t lnglen; /* length for long strings */ + struct TString *hnext; /* linked list for hash table */ + } u; +} TString; /* -** {====================================================== -** types and prototypes -** ======================================================= +** Ensures that address after this type is always fully aligned. */ +typedef union UTString { + L_Umaxalign dummy; /* ensures maximum alignment for strings */ + TString tsv; +} UTString; -union Value { - GCObject *gc; /* collectable objects */ - void *p; /* light userdata */ - int b; /* booleans */ - lua_CFunction f; /* light C functions */ - numfield /* numbers */ -}; - - -struct lua_TValue { - TValuefields; -}; +/* +** Get the actual string (array of bytes) from a 'TString'. +** (Access to 'extra' ensures that value is really a 'TString'.) +*/ +#define getstr(ts) \ + check_exp(sizeof((ts)->extra), cast(char *, (ts)) + sizeof(UTString)) -typedef TValue *StkId; /* index to stack elements */ +/* get the actual string (array of bytes) from a Lua value */ +#define svalue(o) getstr(tsvalue(o)) +/* get string length from 'TString *s' */ +#define tsslen(s) ((s)->tt == LUA_TSHRSTR ? (s)->shrlen : (s)->u.lnglen) +/* get string length from 'TValue *o' */ +#define vslen(o) tsslen(tsvalue(o)) /* -** Header for string value; string bytes follow the end of this structure +** Header for userdata; memory area follows the end of this structure +** (aligned according to 'UUdata'; see next). */ -typedef union TString { - L_Umaxalign dummy; /* ensures maximum alignment for strings */ - struct { - CommonHeader; - lu_byte extra; /* reserved words for short strings; "has hash" for longs */ - unsigned int hash; - size_t len; /* number of characters in string */ - } tsv; -} TString; - +typedef struct Udata { + CommonHeader; + lu_byte ttuv_; /* user value's tag */ + struct Table *metatable; + size_t len; /* number of bytes */ + union Value user_; /* user value */ +} Udata; -/* get the actual string (array of bytes) from a TString */ -#define getstr(ts) cast(const char *, (ts) + 1) -/* get the actual string (array of bytes) from a Lua value */ -#define svalue(o) getstr(rawtsvalue(o)) +/* +** Ensures that address after this type is always fully aligned. +*/ +typedef union UUdata { + L_Umaxalign dummy; /* ensures maximum alignment for 'local' udata */ + Udata uv; +} UUdata; /* -** Header for userdata; memory area follows the end of this structure +** Get the address of memory block inside 'Udata'. +** (Access to 'ttuv_' ensures that value is really a 'Udata'.) */ -typedef union Udata { - L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ - struct { - CommonHeader; - struct Table *metatable; - struct Table *env; - size_t len; /* number of bytes */ - } uv; -} Udata; +#define getudatamem(u) \ + check_exp(sizeof((u)->ttuv_), (cast(char*, (u)) + sizeof(UUdata))) +#define setuservalue(L,u,o) \ + { const TValue *io=(o); Udata *iu = (u); \ + iu->user_ = io->value_; iu->ttuv_ = rttype(io); \ + checkliveness(L,io); } + + +#define getuservalue(L,u,o) \ + { TValue *io=(o); const Udata *iu = (u); \ + io->value_ = iu->user_; settt_(io, iu->ttuv_); \ + checkliveness(L,io); } /* @@ -445,7 +385,7 @@ typedef union Udata { */ typedef struct Upvaldesc { TString *name; /* upvalue name (for debug information) */ - lu_byte instack; /* whether it is in stack */ + lu_byte instack; /* whether it is in stack (register) */ lu_byte idx; /* index of upvalue (in stack or in outer function's list) */ } Upvaldesc; @@ -466,26 +406,26 @@ typedef struct LocVar { */ typedef struct Proto { CommonHeader; + lu_byte numparams; /* number of fixed parameters */ + lu_byte is_vararg; + lu_byte maxstacksize; /* number of registers needed by this function */ + int sizeupvalues; /* size of 'upvalues' */ + int sizek; /* size of 'k' */ + int sizecode; + int sizelineinfo; + int sizep; /* size of 'p' */ + int sizelocvars; + int linedefined; /* debug information */ + int lastlinedefined; /* debug information */ TValue *k; /* constants used by the function */ - Instruction *code; + Instruction *code; /* opcodes */ struct Proto **p; /* functions defined inside the function */ int *lineinfo; /* map from opcodes to source lines (debug information) */ LocVar *locvars; /* information about local variables (debug information) */ Upvaldesc *upvalues; /* upvalue information */ - union Closure *cache; /* last created closure with this prototype */ + struct LClosure *cache; /* last-created closure with this prototype */ TString *source; /* used for debug information */ - int sizeupvalues; /* size of 'upvalues' */ - int sizek; /* size of `k' */ - int sizecode; - int sizelineinfo; - int sizep; /* size of `p' */ - int sizelocvars; - int linedefined; - int lastlinedefined; GCObject *gclist; - lu_byte numparams; /* number of fixed parameters */ - lu_byte is_vararg; - lu_byte maxstacksize; /* maximum stack used by this function */ } Proto; @@ -493,17 +433,7 @@ typedef struct Proto { /* ** Lua Upvalues */ -typedef struct UpVal { - CommonHeader; - TValue *v; /* points to stack or to its own value */ - union { - TValue value; /* the value (when closed) */ - struct { /* double linked list (when open) */ - struct UpVal *prev; - struct UpVal *next; - } l; - } u; -} UpVal; +typedef struct UpVal UpVal; /* @@ -545,12 +475,19 @@ typedef union Closure { typedef union TKey { struct { TValuefields; - struct Node *next; /* for chaining */ + int next; /* for chaining (offset for next node) */ } nk; TValue tvk; } TKey; +/* copy a value into a key without messing up field 'next' */ +#define setnodekey(L,key,obj) \ + { TKey *k_=(key); const TValue *io_=(obj); \ + k_->nk.value_ = io_->value_; k_->nk.tt_ = io_->tt_; \ + (void)L; checkliveness(L,io_); } + + typedef struct Node { TValue i_val; TKey i_key; @@ -560,19 +497,19 @@ typedef struct Node { typedef struct Table { CommonHeader; lu_byte flags; /* 1<

>1) /* `sBx' is signed */ +#define MAXARG_sBx (MAXARG_Bx>>1) /* 'sBx' is signed */ #else #define MAXARG_Bx MAX_INT #define MAXARG_sBx MAX_INT @@ -76,10 +76,10 @@ enum OpMode {iABC, iABx, iAsBx, iAx}; /* basic instruction format */ #define MAXARG_C ((1<> RK(C) */ OP_UNM,/* A B R(A) := -R(B) */ +OP_BNOT,/* A B R(A) := ~R(B) */ OP_NOT,/* A B R(A) := not R(B) */ OP_LEN,/* A B R(A) := length of R(B) */ OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */ -OP_JMP,/* A sBx pc+=sBx; if (A) close all upvalues >= R(A) + 1 */ +OP_JMP,/* A sBx pc+=sBx; if (A) close all upvalues >= R(A - 1) */ OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */ OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */ OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */ @@ -231,16 +240,16 @@ OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */ /*=========================================================================== Notes: - (*) In OP_CALL, if (B == 0) then B = top. If (C == 0), then `top' is + (*) In OP_CALL, if (B == 0) then B = top. If (C == 0), then 'top' is set to last_result+1, so next open instruction (OP_CALL, OP_RETURN, - OP_SETLIST) may use `top'. + OP_SETLIST) may use 'top'. (*) In OP_VARARG, if (B == 0) then use actual number of varargs and set top (like in OP_CALL with C == 0). - (*) In OP_RETURN, if (B == 0) then return up to `top'. + (*) In OP_RETURN, if (B == 0) then return up to 'top'. - (*) In OP_SETLIST, if (B == 0) then B = `top'; if (C == 0) then next + (*) In OP_SETLIST, if (B == 0) then B = 'top'; if (C == 0) then next 'instruction' is EXTRAARG(real C). (*) In OP_LOADKX, the next 'instruction' is always EXTRAARG. @@ -248,7 +257,7 @@ OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */ (*) For comparisons, A specifies what condition the test should accept (true or false). - (*) All `skips' (pc++) assume that next instruction is a jump. + (*) All 'skips' (pc++) assume that next instruction is a jump. ===========================================================================*/ diff --git a/depends/lua/include/lparser.h b/depends/lua/include/lparser.h index 0346e3c41a..f45b23cba5 100644 --- a/depends/lua/include/lparser.h +++ b/depends/lua/include/lparser.h @@ -1,5 +1,5 @@ /* -** $Id: lparser.h,v 1.70.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lparser.h,v 1.76.1.1 2017/04/19 17:20:42 roberto Exp $ ** Lua Parser ** See Copyright Notice in lua.h */ @@ -13,24 +13,38 @@ /* -** Expression descriptor +** Expression and variable descriptor. +** Code generation for variables and expressions can be delayed to allow +** optimizations; An 'expdesc' structure describes a potentially-delayed +** variable/expression. It has a description of its "main" value plus a +** list of conditional jumps that can also produce its value (generated +** by short-circuit operators 'and'/'or'). */ +/* kinds of variables/expressions */ typedef enum { - VVOID, /* no value */ - VNIL, - VTRUE, - VFALSE, - VK, /* info = index of constant in `k' */ - VKNUM, /* nval = numerical value */ - VNONRELOC, /* info = result register */ - VLOCAL, /* info = local register */ - VUPVAL, /* info = index of upvalue in 'upvalues' */ - VINDEXED, /* t = table register/upvalue; idx = index R/K */ - VJMP, /* info = instruction pc */ - VRELOCABLE, /* info = instruction pc */ - VCALL, /* info = instruction pc */ - VVARARG /* info = instruction pc */ + VVOID, /* when 'expdesc' describes the last expression a list, + this kind means an empty list (so, no expression) */ + VNIL, /* constant nil */ + VTRUE, /* constant true */ + VFALSE, /* constant false */ + VK, /* constant in 'k'; info = index of constant in 'k' */ + VKFLT, /* floating constant; nval = numerical float value */ + VKINT, /* integer constant; nval = numerical integer value */ + VNONRELOC, /* expression has its value in a fixed register; + info = result register */ + VLOCAL, /* local variable; info = local register */ + VUPVAL, /* upvalue variable; info = index of upvalue in 'upvalues' */ + VINDEXED, /* indexed variable; + ind.vt = whether 't' is register or upvalue; + ind.t = table register or upvalue; + ind.idx = key's R/K index */ + VJMP, /* expression is a test/comparison; + info = pc of corresponding jump instruction */ + VRELOCABLE, /* expression can put result in any register; + info = instruction pc */ + VCALL, /* expression is a function call; info = instruction pc */ + VVARARG /* vararg expression; info = instruction pc */ } expkind; @@ -40,16 +54,17 @@ typedef enum { typedef struct expdesc { expkind k; union { + lua_Integer ival; /* for VKINT */ + lua_Number nval; /* for VKFLT */ + int info; /* for generic use */ struct { /* for indexed variables (VINDEXED) */ short idx; /* index (R/K) */ lu_byte t; /* table (register or upvalue) */ lu_byte vt; /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */ } ind; - int info; /* for generic use */ - lua_Number nval; /* for VKNUM */ } u; - int t; /* patch list of `exit when true' */ - int f; /* patch list of `exit when false' */ + int t; /* patch list of 'exit when true' */ + int f; /* patch list of 'exit when false' */ } expdesc; @@ -95,15 +110,14 @@ struct BlockCnt; /* defined in lparser.c */ /* state needed to generate code for a given function */ typedef struct FuncState { Proto *f; /* current function header */ - Table *h; /* table to find (and reuse) elements in `k' */ struct FuncState *prev; /* enclosing function */ struct LexState *ls; /* lexical state */ struct BlockCnt *bl; /* chain of current blocks */ - int pc; /* next position to code (equivalent to `ncode') */ + int pc; /* next position to code (equivalent to 'ncode') */ int lasttarget; /* 'label' of last 'jump label' */ - int jpc; /* list of pending jumps to `pc' */ - int nk; /* number of elements in `k' */ - int np; /* number of elements in `p' */ + int jpc; /* list of pending jumps to 'pc' */ + int nk; /* number of elements in 'k' */ + int np; /* number of elements in 'p' */ int firstlocal; /* index of first local var (in Dyndata array) */ short nlocvars; /* number of elements in 'f->locvars' */ lu_byte nactvar; /* number of active local variables */ @@ -112,8 +126,8 @@ typedef struct FuncState { } FuncState; -LUAI_FUNC Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, - Dyndata *dyd, const char *name, int firstchar); +LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, + Dyndata *dyd, const char *name, int firstchar); #endif diff --git a/depends/lua/include/lprefix.h b/depends/lua/include/lprefix.h new file mode 100644 index 0000000000..9a749a3f30 --- /dev/null +++ b/depends/lua/include/lprefix.h @@ -0,0 +1,45 @@ +/* +** $Id: lprefix.h,v 1.2.1.1 2017/04/19 17:20:42 roberto Exp $ +** Definitions for Lua code that must come before any other header file +** See Copyright Notice in lua.h +*/ + +#ifndef lprefix_h +#define lprefix_h + + +/* +** Allows POSIX/XSI stuff +*/ +#if !defined(LUA_USE_C89) /* { */ + +#if !defined(_XOPEN_SOURCE) +#define _XOPEN_SOURCE 600 +#elif _XOPEN_SOURCE == 0 +#undef _XOPEN_SOURCE /* use -D_XOPEN_SOURCE=0 to undefine it */ +#endif + +/* +** Allows manipulation of large files in gcc and some other compilers +*/ +#if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS) +#define _LARGEFILE_SOURCE 1 +#define _FILE_OFFSET_BITS 64 +#endif + +#endif /* } */ + + +/* +** Windows stuff +*/ +#if defined(_WIN32) /* { */ + +#if !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS /* avoid warnings about ISO C functions */ +#endif + +#endif /* } */ + +#endif + diff --git a/depends/lua/include/lstate.h b/depends/lua/include/lstate.h index daffd9aacf..56b3741000 100644 --- a/depends/lua/include/lstate.h +++ b/depends/lua/include/lstate.h @@ -1,5 +1,5 @@ /* -** $Id: lstate.h,v 2.82.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lstate.h,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $ ** Global State ** See Copyright Notice in lua.h */ @@ -16,25 +16,34 @@ /* -** Some notes about garbage-collected objects: All objects in Lua must -** be kept somehow accessible until being freed. +** Some notes about garbage-collected objects: All objects in Lua must +** be kept somehow accessible until being freed, so all objects always +** belong to one (and only one) of these lists, using field 'next' of +** the 'CommonHeader' for the link: ** -** Lua keeps most objects linked in list g->allgc. The link uses field -** 'next' of the CommonHeader. +** 'allgc': all objects not marked for finalization; +** 'finobj': all objects marked for finalization; +** 'tobefnz': all objects ready to be finalized; +** 'fixedgc': all objects that are not to be collected (currently +** only small strings, such as reserved words). ** -** Strings are kept in several lists headed by the array g->strt.hash. +** Moreover, there is another set of lists that control gray objects. +** These lists are linked by fields 'gclist'. (All objects that +** can become gray have such a field. The field is not the same +** in all objects, but it always has this name.) Any gray object +** must belong to one of these lists, and all objects in these lists +** must be gray: ** -** Open upvalues are not subject to independent garbage collection. They -** are collected together with their respective threads. Lua keeps a -** double-linked list with all open upvalues (g->uvhead) so that it can -** mark objects referred by them. (They are always gray, so they must -** be remarked in the atomic step. Usually their contents would be marked -** when traversing the respective threads, but the thread may already be -** dead, while the upvalue is still accessible through closures.) -** -** Objects with finalizers are kept in the list g->finobj. -** -** The list g->tobefnz links all objects being finalized. +** 'gray': regular gray objects, still waiting to be visited. +** 'grayagain': objects that must be revisited at the atomic phase. +** That includes +** - black objects got in a write barrier; +** - all kinds of weak tables during propagation phase; +** - all threads. +** 'weak': tables with weak values to be cleared; +** 'ephemeron': ephemeron tables with white->white entries; +** 'allweak': tables with weak keys and/or weak values to be cleared. +** The last three lists are used only during the atomic phase. */ @@ -42,6 +51,15 @@ struct lua_longjmp; /* defined in ldo.c */ +/* +** Atomic type (relative to signals) to better ensure that 'lua_sethook' +** is thread safe +*/ +#if !defined(l_signalT) +#include +#define l_signalT sig_atomic_t +#endif + /* extra stack space to handle TM calls and some other extras */ #define EXTRA_STACK 5 @@ -53,66 +71,73 @@ struct lua_longjmp; /* defined in ldo.c */ /* kinds of Garbage Collection */ #define KGC_NORMAL 0 #define KGC_EMERGENCY 1 /* gc was forced by an allocation failure */ -#define KGC_GEN 2 /* generational collection */ typedef struct stringtable { - GCObject **hash; - lu_int32 nuse; /* number of elements */ + TString **hash; + int nuse; /* number of elements */ int size; } stringtable; /* -** information about a call +** Information about a call. +** When a thread yields, 'func' is adjusted to pretend that the +** top function has only the yielded values in its stack; in that +** case, the actual 'func' value is saved in field 'extra'. +** When a function calls another with a continuation, 'extra' keeps +** the function index so that, in case of errors, the continuation +** function can be called with the correct top. */ typedef struct CallInfo { StkId func; /* function index in the stack */ StkId top; /* top for this function */ struct CallInfo *previous, *next; /* dynamic call link */ - short nresults; /* expected number of results from this function */ - lu_byte callstatus; - ptrdiff_t extra; union { struct { /* only for Lua functions */ StkId base; /* base for this function */ const Instruction *savedpc; } l; struct { /* only for C functions */ - int ctx; /* context info. in case of yields */ - lua_CFunction k; /* continuation in case of yields */ + lua_KFunction k; /* continuation in case of yields */ ptrdiff_t old_errfunc; - lu_byte old_allowhook; - lu_byte status; + lua_KContext ctx; /* context info. in case of yields */ } c; } u; + ptrdiff_t extra; + short nresults; /* expected number of results from this function */ + unsigned short callstatus; } CallInfo; /* ** Bits in CallInfo status */ -#define CIST_LUA (1<<0) /* call is running a Lua function */ -#define CIST_HOOKED (1<<1) /* call is running a debug hook */ -#define CIST_REENTRY (1<<2) /* call is running on same invocation of - luaV_execute of previous call */ -#define CIST_YIELDED (1<<3) /* call reentered after suspension */ +#define CIST_OAH (1<<0) /* original value of 'allowhook' */ +#define CIST_LUA (1<<1) /* call is running a Lua function */ +#define CIST_HOOKED (1<<2) /* call is running a debug hook */ +#define CIST_FRESH (1<<3) /* call is running on a fresh invocation + of luaV_execute */ #define CIST_YPCALL (1<<4) /* call is a yieldable protected call */ -#define CIST_STAT (1<<5) /* call has an error status (pcall) */ -#define CIST_TAIL (1<<6) /* call was tail called */ -#define CIST_HOOKYIELD (1<<7) /* last hook called yielded */ - +#define CIST_TAIL (1<<5) /* call was tail called */ +#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ +#define CIST_LEQ (1<<7) /* using __lt for __le */ +#define CIST_FIN (1<<8) /* call is running a finalizer */ #define isLua(ci) ((ci)->callstatus & CIST_LUA) +/* assume that CIST_OAH has offset 0 and that 'v' is strictly 0/1 */ +#define setoah(st,v) ((st) = ((st) & ~CIST_OAH) | (v)) +#define getoah(st) ((st) & CIST_OAH) + /* -** `global state', shared by all threads of this state +** 'global state', shared by all threads of this state */ typedef struct global_State { lua_Alloc frealloc; /* function to reallocate memory */ - void *ud; /* auxiliary data to `frealloc' */ - lu_mem totalbytes; /* number of bytes currently allocated - GCdebt */ + void *ud; /* auxiliary data to 'frealloc' */ + l_mem totalbytes; /* number of bytes currently allocated - GCdebt */ l_mem GCdebt; /* bytes allocated not yet compensated by the collector */ lu_mem GCmemtrav; /* memory traversed by the GC */ lu_mem GCestimate; /* an estimate of the non-garbage memory in use */ @@ -123,36 +148,36 @@ typedef struct global_State { lu_byte gcstate; /* state of garbage collector */ lu_byte gckind; /* kind of GC running */ lu_byte gcrunning; /* true if GC is running */ - int sweepstrgc; /* position of sweep in `strt' */ GCObject *allgc; /* list of all collectable objects */ + GCObject **sweepgc; /* current position of sweep in list */ GCObject *finobj; /* list of collectable objects with finalizers */ - GCObject **sweepgc; /* current position of sweep in list 'allgc' */ - GCObject **sweepfin; /* current position of sweep in list 'finobj' */ GCObject *gray; /* list of gray objects */ GCObject *grayagain; /* list of objects to be traversed atomically */ GCObject *weak; /* list of tables with weak values */ GCObject *ephemeron; /* list of ephemeron tables (weak keys) */ GCObject *allweak; /* list of all-weak tables */ GCObject *tobefnz; /* list of userdata to be GC */ - UpVal uvhead; /* head of double-linked list of all open upvalues */ - Mbuffer buff; /* temporary buffer for string concatenation */ + GCObject *fixedgc; /* list of objects not to be collected */ + struct lua_State *twups; /* list of threads with open upvalues */ + unsigned int gcfinnum; /* number of finalizers to call in each GC step */ int gcpause; /* size of pause between successive GCs */ - int gcmajorinc; /* pause between major collections (only in gen. mode) */ - int gcstepmul; /* GC `granularity' */ + int gcstepmul; /* GC 'granularity' */ lua_CFunction panic; /* to be called in unprotected errors */ struct lua_State *mainthread; const lua_Number *version; /* pointer to version number */ TString *memerrmsg; /* memory-error message */ TString *tmname[TM_N]; /* array with tag-method names */ struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */ + TString *strcache[STRCACHE_N][STRCACHE_M]; /* cache for strings in API */ } global_State; /* -** `per thread' state +** 'per thread' state */ struct lua_State { CommonHeader; + unsigned short nci; /* number of items in 'ci' list */ lu_byte status; StkId top; /* first free slot in the stack */ global_State *l_G; @@ -160,19 +185,20 @@ struct lua_State { const Instruction *oldpc; /* last pc traced */ StkId stack_last; /* last free slot in the stack */ StkId stack; /* stack base */ + UpVal *openupval; /* list of open upvalues in this stack */ + GCObject *gclist; + struct lua_State *twups; /* list of threads with open upvalues */ + struct lua_longjmp *errorJmp; /* current error recover point */ + CallInfo base_ci; /* CallInfo for first level (C calling Lua) */ + volatile lua_Hook hook; + ptrdiff_t errfunc; /* current error handling function (stack index) */ int stacksize; + int basehookcount; + int hookcount; unsigned short nny; /* number of non-yieldable calls in stack */ unsigned short nCcalls; /* number of nested C calls */ - lu_byte hookmask; + l_signalT hookmask; lu_byte allowhook; - int basehookcount; - int hookcount; - lua_Hook hook; - GCObject *openupval; /* list of open upvalues in this stack */ - GCObject *gclist; - struct lua_longjmp *errorJmp; /* current error recover point */ - ptrdiff_t errfunc; /* current error handling function (stack index) */ - CallInfo base_ci; /* CallInfo for first level (C calling Lua) */ }; @@ -180,48 +206,47 @@ struct lua_State { /* -** Union of all collectable objects +** Union of all collectable objects (only for conversions) */ -union GCObject { - GCheader gch; /* common header */ - union TString ts; - union Udata u; +union GCUnion { + GCObject gc; /* common header */ + struct TString ts; + struct Udata u; union Closure cl; struct Table h; struct Proto p; - struct UpVal uv; struct lua_State th; /* thread */ }; -#define gch(o) (&(o)->gch) +#define cast_u(o) cast(union GCUnion *, (o)) /* macros to convert a GCObject into a specific value */ -#define rawgco2ts(o) \ - check_exp(novariant((o)->gch.tt) == LUA_TSTRING, &((o)->ts)) -#define gco2ts(o) (&rawgco2ts(o)->tsv) -#define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u)) -#define gco2u(o) (&rawgco2u(o)->uv) -#define gco2lcl(o) check_exp((o)->gch.tt == LUA_TLCL, &((o)->cl.l)) -#define gco2ccl(o) check_exp((o)->gch.tt == LUA_TCCL, &((o)->cl.c)) +#define gco2ts(o) \ + check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) +#define gco2u(o) check_exp((o)->tt == LUA_TUSERDATA, &((cast_u(o))->u)) +#define gco2lcl(o) check_exp((o)->tt == LUA_TLCL, &((cast_u(o))->cl.l)) +#define gco2ccl(o) check_exp((o)->tt == LUA_TCCL, &((cast_u(o))->cl.c)) #define gco2cl(o) \ - check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl)) -#define gco2t(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h)) -#define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p)) -#define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv)) -#define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th)) + check_exp(novariant((o)->tt) == LUA_TFUNCTION, &((cast_u(o))->cl)) +#define gco2t(o) check_exp((o)->tt == LUA_TTABLE, &((cast_u(o))->h)) +#define gco2p(o) check_exp((o)->tt == LUA_TPROTO, &((cast_u(o))->p)) +#define gco2th(o) check_exp((o)->tt == LUA_TTHREAD, &((cast_u(o))->th)) + -/* macro to convert any Lua object into a GCObject */ -#define obj2gco(v) (cast(GCObject *, (v))) +/* macro to convert a Lua object into a GCObject */ +#define obj2gco(v) \ + check_exp(novariant((v)->tt) < LUA_TDEADKEY, (&(cast_u(v)->gc))) /* actual number of total bytes allocated */ -#define gettotalbytes(g) ((g)->totalbytes + (g)->GCdebt) +#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt); LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1); LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L); LUAI_FUNC void luaE_freeCI (lua_State *L); +LUAI_FUNC void luaE_shrinkCI (lua_State *L); #endif diff --git a/depends/lua/include/lstring.h b/depends/lua/include/lstring.h index 260e7f169b..d612abd333 100644 --- a/depends/lua/include/lstring.h +++ b/depends/lua/include/lstring.h @@ -1,5 +1,5 @@ /* -** $Id: lstring.h,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lstring.h,v 1.61.1.1 2017/04/19 17:20:42 roberto Exp $ ** String table (keep all strings handled by Lua) ** See Copyright Notice in lua.h */ @@ -12,35 +12,38 @@ #include "lstate.h" -#define sizestring(s) (sizeof(union TString)+((s)->len+1)*sizeof(char)) +#define sizelstring(l) (sizeof(union UTString) + ((l) + 1) * sizeof(char)) -#define sizeudata(u) (sizeof(union Udata)+(u)->len) +#define sizeludata(l) (sizeof(union UUdata) + (l)) +#define sizeudata(u) sizeludata((u)->len) #define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ (sizeof(s)/sizeof(char))-1)) -#define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT) - /* ** test whether a string is a reserved word */ -#define isreserved(s) ((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0) +#define isreserved(s) ((s)->tt == LUA_TSHRSTR && (s)->extra > 0) /* ** equality for short strings, which are always internalized */ -#define eqshrstr(a,b) check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b)) +#define eqshrstr(a,b) check_exp((a)->tt == LUA_TSHRSTR, (a) == (b)) LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed); +LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts); LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b); -LUAI_FUNC int luaS_eqstr (TString *a, TString *b); LUAI_FUNC void luaS_resize (lua_State *L, int newsize); -LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e); +LUAI_FUNC void luaS_clearcache (global_State *g); +LUAI_FUNC void luaS_init (lua_State *L); +LUAI_FUNC void luaS_remove (lua_State *L, TString *ts); +LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s); LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); LUAI_FUNC TString *luaS_new (lua_State *L, const char *str); +LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l); #endif diff --git a/depends/lua/include/ltable.h b/depends/lua/include/ltable.h index d69449b2b8..92db0ac7bf 100644 --- a/depends/lua/include/ltable.h +++ b/depends/lua/include/ltable.h @@ -1,5 +1,5 @@ /* -** $Id: ltable.h,v 2.16.1.2 2013/08/30 15:49:41 roberto Exp $ +** $Id: ltable.h,v 2.23.1.2 2018/05/24 19:39:05 roberto Exp $ ** Lua tables (hash) ** See Copyright Notice in lua.h */ @@ -11,34 +11,55 @@ #define gnode(t,i) (&(t)->node[i]) -#define gkey(n) (&(n)->i_key.tvk) #define gval(n) (&(n)->i_val) #define gnext(n) ((n)->i_key.nk.next) + +/* 'const' to avoid wrong writings that can mess up field 'next' */ +#define gkey(n) cast(const TValue*, (&(n)->i_key.tvk)) + +/* +** writable version of 'gkey'; allows updates to individual fields, +** but not to the whole (which has incompatible type) +*/ +#define wgkey(n) (&(n)->i_key.nk) + #define invalidateTMcache(t) ((t)->flags = 0) + +/* true when 't' is using 'dummynode' as its hash part */ +#define isdummy(t) ((t)->lastfree == NULL) + + +/* allocated size for hash nodes */ +#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) + + /* returns the key, given the value of a table entry */ #define keyfromval(v) \ (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val)))) -LUAI_FUNC const TValue *luaH_getint (Table *t, int key); -LUAI_FUNC void luaH_setint (lua_State *L, Table *t, int key, TValue *value); +LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key); +LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key, + TValue *value); +LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key); LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key); LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key); LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key); LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key); LUAI_FUNC Table *luaH_new (lua_State *L); -LUAI_FUNC void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize); -LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize); +LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize, + unsigned int nhsize); +LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize); LUAI_FUNC void luaH_free (lua_State *L, Table *t); LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key); -LUAI_FUNC int luaH_getn (Table *t); +LUAI_FUNC lua_Unsigned luaH_getn (Table *t); #if defined(LUA_DEBUG) LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key); -LUAI_FUNC int luaH_isdummy (Node *n); +LUAI_FUNC int luaH_isdummy (const Table *t); #endif diff --git a/depends/lua/include/ltm.h b/depends/lua/include/ltm.h index 7f89c841f9..8170688dae 100644 --- a/depends/lua/include/ltm.h +++ b/depends/lua/include/ltm.h @@ -1,5 +1,5 @@ /* -** $Id: ltm.h,v 2.11.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: ltm.h,v 2.22.1.1 2017/04/19 17:20:42 roberto Exp $ ** Tag methods ** See Copyright Notice in lua.h */ @@ -13,7 +13,7 @@ /* * WARNING: if you change the order of this enumeration, -* grep "ORDER TM" +* grep "ORDER TM" and "ORDER OP" */ typedef enum { TM_INDEX, @@ -21,14 +21,21 @@ typedef enum { TM_GC, TM_MODE, TM_LEN, - TM_EQ, /* last tag method with `fast' access */ + TM_EQ, /* last tag method with fast access */ TM_ADD, TM_SUB, TM_MUL, - TM_DIV, TM_MOD, TM_POW, + TM_DIV, + TM_IDIV, + TM_BAND, + TM_BOR, + TM_BXOR, + TM_SHL, + TM_SHR, TM_UNM, + TM_BNOT, TM_LT, TM_LE, TM_CONCAT, @@ -44,14 +51,26 @@ typedef enum { #define fasttm(l,et,e) gfasttm(G(l), et, e) #define ttypename(x) luaT_typenames_[(x) + 1] -#define objtypename(x) ttypename(ttypenv(x)) LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS]; +LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o); + LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename); LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event); LUAI_FUNC void luaT_init (lua_State *L); +LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1, + const TValue *p2, TValue *p3, int hasres); +LUAI_FUNC int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2, + StkId res, TMS event); +LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2, + StkId res, TMS event); +LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1, + const TValue *p2, TMS event); + + + #endif diff --git a/depends/lua/include/lua.h b/depends/lua/include/lua.h index 149a2c37bc..9394c5ef8f 100644 --- a/depends/lua/include/lua.h +++ b/depends/lua/include/lua.h @@ -1,5 +1,4 @@ /* -** $Id: lua.h,v 1.285.1.2 2013/11/11 12:09:16 roberto Exp $ ** Lua - A Scripting Language ** Lua.org, PUC-Rio, Brazil (http://www.lua.org) ** See Copyright Notice at the end of this file @@ -17,27 +16,29 @@ #define LUA_VERSION_MAJOR "5" -#define LUA_VERSION_MINOR "2" -#define LUA_VERSION_NUM 502 -#define LUA_VERSION_RELEASE "3" +#define LUA_VERSION_MINOR "3" +#define LUA_VERSION_NUM 503 +#define LUA_VERSION_RELEASE "6" #define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR #define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE -#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2013 Lua.org, PUC-Rio" +#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2020 Lua.org, PUC-Rio" #define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" /* mark for precompiled code ('Lua') */ -#define LUA_SIGNATURE "\033Lua" +#define LUA_SIGNATURE "\x1bLua" /* option for multiple returns in 'lua_pcall' and 'lua_call' */ #define LUA_MULTRET (-1) /* -** pseudo-indices +** Pseudo-indices +** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty +** space after that to help overflow detection) */ -#define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX +#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) #define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) @@ -53,22 +54,6 @@ typedef struct lua_State lua_State; -typedef int (*lua_CFunction) (lua_State *L); - - -/* -** functions that read/write blocks when loading/dumping Lua chunks -*/ -typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); - -typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud); - - -/* -** prototype for memory-allocation functions -*/ -typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); - /* ** basic types @@ -109,6 +94,34 @@ typedef LUA_INTEGER lua_Integer; /* unsigned integer type */ typedef LUA_UNSIGNED lua_Unsigned; +/* type for continuation-function contexts */ +typedef LUA_KCONTEXT lua_KContext; + + +/* +** Type for C functions registered with Lua +*/ +typedef int (*lua_CFunction) (lua_State *L); + +/* +** Type for continuation functions +*/ +typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); + + +/* +** Type for functions that read/write blocks when loading/dumping Lua chunks +*/ +typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); + +typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud); + + +/* +** Type for memory-allocation functions +*/ +typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); + /* @@ -145,11 +158,9 @@ LUA_API int (lua_absindex) (lua_State *L, int idx); LUA_API int (lua_gettop) (lua_State *L); LUA_API void (lua_settop) (lua_State *L, int idx); LUA_API void (lua_pushvalue) (lua_State *L, int idx); -LUA_API void (lua_remove) (lua_State *L, int idx); -LUA_API void (lua_insert) (lua_State *L, int idx); -LUA_API void (lua_replace) (lua_State *L, int idx); +LUA_API void (lua_rotate) (lua_State *L, int idx, int n); LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); -LUA_API int (lua_checkstack) (lua_State *L, int sz); +LUA_API int (lua_checkstack) (lua_State *L, int n); LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); @@ -161,13 +172,13 @@ LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); LUA_API int (lua_isnumber) (lua_State *L, int idx); LUA_API int (lua_isstring) (lua_State *L, int idx); LUA_API int (lua_iscfunction) (lua_State *L, int idx); +LUA_API int (lua_isinteger) (lua_State *L, int idx); LUA_API int (lua_isuserdata) (lua_State *L, int idx); LUA_API int (lua_type) (lua_State *L, int idx); LUA_API const char *(lua_typename) (lua_State *L, int tp); LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum); LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum); -LUA_API lua_Unsigned (lua_tounsignedx) (lua_State *L, int idx, int *isnum); LUA_API int (lua_toboolean) (lua_State *L, int idx); LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); LUA_API size_t (lua_rawlen) (lua_State *L, int idx); @@ -181,13 +192,20 @@ LUA_API const void *(lua_topointer) (lua_State *L, int idx); ** Comparison and arithmetic functions */ -#define LUA_OPADD 0 /* ORDER TM */ +#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ #define LUA_OPSUB 1 #define LUA_OPMUL 2 -#define LUA_OPDIV 3 -#define LUA_OPMOD 4 -#define LUA_OPPOW 5 -#define LUA_OPUNM 6 +#define LUA_OPMOD 3 +#define LUA_OPPOW 4 +#define LUA_OPDIV 5 +#define LUA_OPIDIV 6 +#define LUA_OPBAND 7 +#define LUA_OPBOR 8 +#define LUA_OPBXOR 9 +#define LUA_OPSHL 10 +#define LUA_OPSHR 11 +#define LUA_OPUNM 12 +#define LUA_OPBNOT 13 LUA_API void (lua_arith) (lua_State *L, int op); @@ -205,8 +223,7 @@ LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); LUA_API void (lua_pushnil) (lua_State *L); LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n); LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n); -LUA_API void (lua_pushunsigned) (lua_State *L, lua_Unsigned n); -LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l); +LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len); LUA_API const char *(lua_pushstring) (lua_State *L, const char *s); LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, va_list argp); @@ -220,26 +237,29 @@ LUA_API int (lua_pushthread) (lua_State *L); /* ** get functions (Lua -> stack) */ -LUA_API void (lua_getglobal) (lua_State *L, const char *var); -LUA_API void (lua_gettable) (lua_State *L, int idx); -LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k); -LUA_API void (lua_rawget) (lua_State *L, int idx); -LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n); -LUA_API void (lua_rawgetp) (lua_State *L, int idx, const void *p); +LUA_API int (lua_getglobal) (lua_State *L, const char *name); +LUA_API int (lua_gettable) (lua_State *L, int idx); +LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k); +LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawget) (lua_State *L, int idx); +LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p); + LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz); LUA_API int (lua_getmetatable) (lua_State *L, int objindex); -LUA_API void (lua_getuservalue) (lua_State *L, int idx); +LUA_API int (lua_getuservalue) (lua_State *L, int idx); /* ** set functions (stack -> Lua) */ -LUA_API void (lua_setglobal) (lua_State *L, const char *var); +LUA_API void (lua_setglobal) (lua_State *L, const char *name); LUA_API void (lua_settable) (lua_State *L, int idx); LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k); +LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n); LUA_API void (lua_rawset) (lua_State *L, int idx); -LUA_API void (lua_rawseti) (lua_State *L, int idx, int n); +LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n); LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p); LUA_API int (lua_setmetatable) (lua_State *L, int objindex); LUA_API void (lua_setuservalue) (lua_State *L, int idx); @@ -248,31 +268,31 @@ LUA_API void (lua_setuservalue) (lua_State *L, int idx); /* ** 'load' and 'call' functions (load and run Lua code) */ -LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, int ctx, - lua_CFunction k); +LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, + lua_KContext ctx, lua_KFunction k); #define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) -LUA_API int (lua_getctx) (lua_State *L, int *ctx); - LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, - int ctx, lua_CFunction k); + lua_KContext ctx, lua_KFunction k); #define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, - const char *chunkname, - const char *mode); + const char *chunkname, const char *mode); -LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data); +LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip); /* ** coroutine functions */ -LUA_API int (lua_yieldk) (lua_State *L, int nresults, int ctx, - lua_CFunction k); +LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx, + lua_KFunction k); +LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg); +LUA_API int (lua_status) (lua_State *L); +LUA_API int (lua_isyieldable) (lua_State *L); + #define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) -LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg); -LUA_API int (lua_status) (lua_State *L); + /* ** garbage-collection function and options @@ -286,10 +306,7 @@ LUA_API int (lua_status) (lua_State *L); #define LUA_GCSTEP 5 #define LUA_GCSETPAUSE 6 #define LUA_GCSETSTEPMUL 7 -#define LUA_GCSETMAJORINC 8 #define LUA_GCISRUNNING 9 -#define LUA_GCGEN 10 -#define LUA_GCINC 11 LUA_API int (lua_gc) (lua_State *L, int what, int data); @@ -305,20 +322,23 @@ LUA_API int (lua_next) (lua_State *L, int idx); LUA_API void (lua_concat) (lua_State *L, int n); LUA_API void (lua_len) (lua_State *L, int idx); +LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s); + LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); /* -** =============================================================== +** {============================================================== ** some useful macros ** =============================================================== */ -#define lua_tonumber(L,i) lua_tonumberx(L,i,NULL) -#define lua_tointeger(L,i) lua_tointegerx(L,i,NULL) -#define lua_tounsigned(L,i) lua_tounsignedx(L,i,NULL) +#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE)) + +#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) +#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) #define lua_pop(L,n) lua_settop(L, -(n)-1) @@ -337,15 +357,36 @@ LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); #define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) #define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) -#define lua_pushliteral(L, s) \ - lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1) +#define lua_pushliteral(L, s) lua_pushstring(L, "" s) #define lua_pushglobaltable(L) \ - lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS) + ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) #define lua_tostring(L,i) lua_tolstring(L, (i), NULL) +#define lua_insert(L,idx) lua_rotate(L, (idx), 1) + +#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) + +#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) + +/* }============================================================== */ + + +/* +** {============================================================== +** compatibility macros for unsigned conversions +** =============================================================== +*/ +#if defined(LUA_COMPAT_APIINTCASTS) + +#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) +#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) +#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) + +#endif +/* }============================================================== */ /* ** {====================================================================== @@ -390,7 +431,7 @@ LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n); LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, int fidx2, int n2); -LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count); +LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count); LUA_API lua_Hook (lua_gethook) (lua_State *L); LUA_API int (lua_gethookmask) (lua_State *L); LUA_API int (lua_gethookcount) (lua_State *L); @@ -418,7 +459,7 @@ struct lua_Debug { /****************************************************************************** -* Copyright (C) 1994-2013 Lua.org, PUC-Rio. +* Copyright (C) 1994-2020 Lua.org, PUC-Rio. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the diff --git a/depends/lua/include/luaconf.h b/depends/lua/include/luaconf.h index af09ffb946..ffdfe05953 100644 --- a/depends/lua/include/luaconf.h +++ b/depends/lua/include/luaconf.h @@ -1,85 +1,194 @@ /* -** $Id: luaconf.h,v 1.176.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: luaconf.h,v 1.259.1.1 2017/04/19 17:29:57 roberto Exp $ ** Configuration file for Lua ** See Copyright Notice in lua.h */ -#ifndef lconfig_h -#define lconfig_h +#ifndef luaconf_h +#define luaconf_h #include #include +// !! BEGIN DFHack modifications: compatibility +#define LUA_COMPAT_APIINTCASTS +#define LUA_COMPAT_IPAIRS + +// Patch for old glibc versions +#if !defined(LLONG_MAX) && defined(__LONG_LONG_MAX__) +#define LLONG_MAX __LONG_LONG_MAX__ +#endif + +#if !defined(LLONG_MIN) && defined(__LONG_LONG_MAX__) +#define LLONG_MIN (-__LONG_LONG_MAX__ - 1LL) +#endif +// !! END DFHack modifications: compatibility /* -** ================================================================== +** =================================================================== ** Search for "@@" to find all configurable definitions. ** =================================================================== */ /* -@@ LUA_ANSI controls the use of non-ansi features. -** CHANGE it (define it) if you want Lua to avoid the use of any -** non-ansi feature or library. +** {==================================================================== +** System Configuration: macros to adapt (if needed) Lua to some +** particular platform, for instance compiling it with 32-bit numbers or +** restricting it to C89. +** ===================================================================== */ -#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__) -#define LUA_ANSI -#endif + +/* +@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You +** can also define LUA_32BITS in the make file, but changing here you +** ensure that all software connected to Lua will be compiled with the +** same configuration. +*/ +/* #define LUA_32BITS */ -#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE) -#define LUA_WIN /* enable goodies for regular Windows platforms */ -#endif +/* +@@ LUA_USE_C89 controls the use of non-ISO-C89 features. +** Define it if you want Lua to avoid the use of a few C99 features +** or Windows-specific features on Windows. +*/ +/* #define LUA_USE_C89 */ -#if defined(LUA_WIN) -#define LUA_DL_DLL -#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ + +/* +** By default, Lua on Windows use (some) specific Windows features +*/ +#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) +#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ #endif +#if defined(LUA_USE_WINDOWS) +#define LUA_DL_DLL /* enable support for DLL */ +#define LUA_USE_C89 /* broadly, Windows is C89 */ +#endif + #if defined(LUA_USE_LINUX) #define LUA_USE_POSIX #define LUA_USE_DLOPEN /* needs an extra library: -ldl */ #define LUA_USE_READLINE /* needs some extra libraries */ -#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */ -#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ -#define LUA_USE_LONGLONG /* assume support for long long */ #endif + #if defined(LUA_USE_MACOSX) #define LUA_USE_POSIX -#define LUA_USE_DLOPEN /* does not need -ldl */ +#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ #define LUA_USE_READLINE /* needs an extra library: -lreadline */ -#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */ -#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ -#define LUA_USE_LONGLONG /* assume support for long long */ #endif +/* +@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for +** C89 ('long' and 'double'); Windows always has '__int64', so it does +** not need to use this case. +*/ +#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS) +#define LUA_C89_NUMBERS +#endif + + + +/* +@@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'. +*/ +/* avoid undefined shifts */ +#if ((INT_MAX >> 15) >> 15) >= 1 +#define LUAI_BITSINT 32 +#else +/* 'int' always must have at least 16 bits */ +#define LUAI_BITSINT 16 +#endif + + +/* +@@ LUA_INT_TYPE defines the type for Lua integers. +@@ LUA_FLOAT_TYPE defines the type for Lua floats. +** Lua should work fine with any mix of these options (if supported +** by your C compiler). The usual configurations are 64-bit integers +** and 'double' (the default), 32-bit integers and 'float' (for +** restricted platforms), and 'long'/'double' (for C compilers not +** compliant with C99, which may not have support for 'long long'). +*/ + +/* predefined options for LUA_INT_TYPE */ +#define LUA_INT_INT 1 +#define LUA_INT_LONG 2 +#define LUA_INT_LONGLONG 3 + +/* predefined options for LUA_FLOAT_TYPE */ +#define LUA_FLOAT_FLOAT 1 +#define LUA_FLOAT_DOUBLE 2 +#define LUA_FLOAT_LONGDOUBLE 3 + +#if defined(LUA_32BITS) /* { */ +/* +** 32-bit integers and 'float' +*/ +#if LUAI_BITSINT >= 32 /* use 'int' if big enough */ +#define LUA_INT_TYPE LUA_INT_INT +#else /* otherwise use 'long' */ +#define LUA_INT_TYPE LUA_INT_LONG +#endif +#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT +#elif defined(LUA_C89_NUMBERS) /* }{ */ /* -@@ LUA_USE_POSIX includes all functionality listed as X/Open System -@* Interfaces Extension (XSI). -** CHANGE it (define it) if your system is XSI compatible. +** largest types available for C89 ('long' and 'double') */ -#if defined(LUA_USE_POSIX) -#define LUA_USE_MKSTEMP -#define LUA_USE_ISATTY -#define LUA_USE_POPEN -#define LUA_USE_ULONGJMP -#define LUA_USE_GMTIME_R +#define LUA_INT_TYPE LUA_INT_LONG +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE + +#endif /* } */ + + +/* +** default configuration for 64-bit Lua ('long long' and 'double') +*/ +#if !defined(LUA_INT_TYPE) +#define LUA_INT_TYPE LUA_INT_LONGLONG +#endif + +#if !defined(LUA_FLOAT_TYPE) +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE #endif +/* }================================================================== */ + + + + +/* +** {================================================================== +** Configuration for Paths. +** =================================================================== +*/ + +/* +** LUA_PATH_SEP is the character that separates templates in a path. +** LUA_PATH_MARK is the string that marks the substitution points in a +** template. +** LUA_EXEC_DIR in a Windows path is replaced by the executable's +** directory. +*/ +#define LUA_PATH_SEP ";" +#define LUA_PATH_MARK "?" +#define LUA_EXEC_DIR "!" +// !! BEGIN DFHack modifications: library paths /* @@ LUA_PATH_DEFAULT is the default path that Lua uses to look for -@* Lua libraries. +** Lua libraries. @@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for -@* C libraries. +** C libraries. ** CHANGE them if your machine has a non-conventional directory ** hierarchy or if you want to install your libraries in ** non-conventional directories. @@ -106,8 +215,9 @@ LUA_CDIR"?.so;" "./?.so" #endif /* } */ -#define LUA_PATH "DFHACK_LUA_PATH" -#define LUA_CPATH "DFHACK_LUA_CPATH" +#define LUA_PATH_VAR "DFHACK_LUA_PATH" +#define LUA_CPATH_VAR "DFHACK_LUA_CPATH" +// !! END DFHack modifications: library paths /* @@ LUA_DIRSEP is the directory separator (for submodules). @@ -120,14 +230,14 @@ #define LUA_DIRSEP "/" #endif +/* }================================================================== */ + /* -@@ LUA_ENV is the name of the variable that holds the current -@@ environment, used to access global names. -** CHANGE it if you do not like this name. +** {================================================================== +** Marks for exported symbols in the C code +** =================================================================== */ -#define LUA_ENV "_ENV" - /* @@ LUA_API is a mark for all core API functions. @@ -140,6 +250,7 @@ */ #if defined(LUA_BUILD_AS_DLL) /* { */ +// !! BEGIN DFHack modifications: symbol exporting #if defined(_MSC_VER) #if defined(LUA_CORE) || defined(LUA_LIB) /* { */ #define LUA_API __declspec(dllexport) @@ -149,6 +260,7 @@ #else #define LUA_API __attribute__ ((visibility("default"))) #endif +// !! END DFHack modifications: symbol exporting #else /* }{ */ @@ -164,10 +276,10 @@ /* @@ LUAI_FUNC is a mark for all extern functions that are not to be -@* exported to outside modules. +** exported to outside modules. @@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables -@* that are not to be exported to outside modules (LUAI_DDEF for -@* definitions and LUAI_DDEC for declarations). +** that are not to be exported to outside modules (LUAI_DDEF for +** definitions and LUAI_DDEC for declarations). ** CHANGE them if you need to mark them in some special way. Elf/gcc ** (versions 3.2 and later) mark them as "hidden" to optimize access ** when Lua is compiled as a shared library. Not all elf targets support @@ -179,74 +291,61 @@ #if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ defined(__ELF__) /* { */ #define LUAI_FUNC __attribute__((visibility("hidden"))) extern -#define LUAI_DDEC LUAI_FUNC -#define LUAI_DDEF /* empty */ - #else /* }{ */ #define LUAI_FUNC extern -#define LUAI_DDEC extern -#define LUAI_DDEF /* empty */ #endif /* } */ +#define LUAI_DDEC LUAI_FUNC +#define LUAI_DDEF /* empty */ + +/* }================================================================== */ /* -@@ LUA_QL describes how error messages quote program elements. -** CHANGE it if you want a different appearance. +** {================================================================== +** Compatibility with previous versions +** =================================================================== */ -#define LUA_QL(x) "'" x "'" -#define LUA_QS LUA_QL("%s") - /* -@@ LUA_IDSIZE gives the maximum size for the description of the source -@* of a function in debug information. -** CHANGE it if you want a different size. +@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2. +@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1. +** You can define it to get all options, or change specific options +** to fit your specific needs. */ -#define LUA_IDSIZE 60 - +#if defined(LUA_COMPAT_5_2) /* { */ /* -@@ luai_writestring/luai_writeline define how 'print' prints its results. -** They are only used in libraries and the stand-alone program. (The #if -** avoids including 'stdio.h' everywhere.) +@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated +** functions in the mathematical library. */ -#if defined(LUA_LIB) || defined(lua_c) -#include -#define luai_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) -#define luai_writeline() (luai_writestring("\n", 1), fflush(stdout)) -#endif +#define LUA_COMPAT_MATHLIB /* -@@ luai_writestringerror defines how to print error messages. -** (A format string with one argument is enough for Lua...) +@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'. */ -#define luai_writestringerror(s,p) \ - (fprintf(stderr, (s), (p)), fflush(stderr)) +#define LUA_COMPAT_BITLIB +/* +@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod. +*/ +#define LUA_COMPAT_IPAIRS /* -@@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is, -** strings that are internalized. (Cannot be smaller than reserved words -** or tags for metamethods, as these strings must be internalized; -** #("function") = 8, #("__newindex") = 10.) +@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for +** manipulating other integer types (lua_pushunsigned, lua_tounsigned, +** luaL_checkint, luaL_checklong, etc.) */ -#define LUAI_MAXSHORTLEN 40 +#define LUA_COMPAT_APIINTCASTS +#endif /* } */ -/* -** {================================================================== -** Compatibility with previous versions -** =================================================================== -*/ +#if defined(LUA_COMPAT_5_1) /* { */ -/* -@@ LUA_COMPAT_ALL controls all compatibility options. -** You can define it to get all options, or change specific options -** to fit your specific needs. -*/ -#if defined(LUA_COMPAT_ALL) /* { */ +/* Incompatibilities from 5.2 -> 5.3 */ +#define LUA_COMPAT_MATHLIB +#define LUA_COMPAT_APIINTCASTS /* @@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'. @@ -307,237 +406,386 @@ #endif /* } */ + +/* +@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a +@@ a float mark ('.0'). +** This macro is not on by default even in compatibility mode, +** because this is not really an incompatibility. +*/ +/* #define LUA_COMPAT_FLOATSTRING */ + /* }================================================================== */ /* -@@ LUAI_BITSINT defines the number of bits in an int. -** CHANGE here if Lua cannot automatically detect the number of bits of -** your machine. Probably you do not need to change this. +** {================================================================== +** Configuration for Numbers. +** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_* +** satisfy your needs. +** =================================================================== */ -/* avoid overflows in comparison */ -#if INT_MAX-20 < 32760 /* { */ -#define LUAI_BITSINT 16 -#elif INT_MAX > 2147483640L /* }{ */ -/* int has at least 32 bits */ -#define LUAI_BITSINT 32 -#else /* }{ */ -#error "you must define LUA_BITSINT with number of bits in an integer" -#endif /* } */ +/* +@@ LUA_NUMBER is the floating-point type used by Lua. +@@ LUAI_UACNUMBER is the result of a 'default argument promotion' +@@ over a floating number. +@@ l_mathlim(x) corrects limit name 'x' to the proper float type +** by prefixing it with one of FLT/DBL/LDBL. +@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats. +@@ LUA_NUMBER_FMT is the format for writing floats. +@@ lua_number2str converts a float to a string. +@@ l_mathop allows the addition of an 'l' or 'f' to all math operations. +@@ l_floor takes the floor of a float. +@@ lua_str2number converts a decimal numeric string to a number. +*/ + + +/* The following definitions are good for most cases here */ + +#define l_floor(x) (l_mathop(floor)(x)) + +#define lua_number2str(s,sz,n) \ + l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) /* -@@ LUA_INT32 is an signed integer with exactly 32 bits. -@@ LUAI_UMEM is an unsigned integer big enough to count the total -@* memory used by Lua. -@@ LUAI_MEM is a signed integer big enough to count the total memory -@* used by Lua. -** CHANGE here if for some weird reason the default definitions are not -** good enough for your machine. Probably you do not need to change -** this. +@@ lua_numbertointeger converts a float number to an integer, or +** returns 0 if float is not within the range of a lua_Integer. +** (The range comparisons are tricky because of rounding. The tests +** here assume a two-complement representation, where MININTEGER always +** has an exact representation as a float; MAXINTEGER may not have one, +** and therefore its conversion to float may have an ill-defined value.) */ -#if LUAI_BITSINT >= 32 /* { */ -#define LUA_INT32 int -#define LUAI_UMEM size_t -#define LUAI_MEM ptrdiff_t -#else /* }{ */ -/* 16-bit ints */ -#define LUA_INT32 long -#define LUAI_UMEM unsigned long -#define LUAI_MEM long -#endif /* } */ +#define lua_numbertointeger(n,p) \ + ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ + (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ + (*(p) = (LUA_INTEGER)(n), 1)) + + +/* now the variable definitions */ + +#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ + +#define LUA_NUMBER float + +#define l_mathlim(n) (FLT_##n) + +#define LUAI_UACNUMBER double + +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.7g" + +#define l_mathop(op) op##f + +#define lua_str2number(s,p) strtof((s), (p)) + + +#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ + +#define LUA_NUMBER long double + +#define l_mathlim(n) (LDBL_##n) + +#define LUAI_UACNUMBER long double + +#define LUA_NUMBER_FRMLEN "L" +#define LUA_NUMBER_FMT "%.19Lg" + +#define l_mathop(op) op##l + +#define lua_str2number(s,p) strtold((s), (p)) + +#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ + +#define LUA_NUMBER double + +#define l_mathlim(n) (DBL_##n) + +#define LUAI_UACNUMBER double + +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.14g" + +#define l_mathop(op) op + +#define lua_str2number(s,p) strtod((s), (p)) + +#else /* }{ */ + +#error "numeric float type not defined" + +#endif /* } */ + /* -@@ LUAI_MAXSTACK limits the size of the Lua stack. -** CHANGE it if you need a different limit. This limit is arbitrary; -** its only purpose is to stop Lua to consume unlimited stack -** space (and to reserve some numbers for pseudo-indices). +@@ LUA_INTEGER is the integer type used by Lua. +** +@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER. +** +@@ LUAI_UACINT is the result of a 'default argument promotion' +@@ over a lUA_INTEGER. +@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers. +@@ LUA_INTEGER_FMT is the format for writing integers. +@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER. +@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER. +@@ lua_integer2str converts an integer to a string. */ -#if LUAI_BITSINT >= 32 -#define LUAI_MAXSTACK 1000000 -#else -#define LUAI_MAXSTACK 15000 -#endif -/* reserve some space for error handling */ -#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000) +/* The following definitions are good for most cases here */ +#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" +#define LUAI_UACINT LUA_INTEGER + +#define lua_integer2str(s,sz,n) \ + l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) /* -@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. -** CHANGE it if it uses too much C-stack space. +** use LUAI_UACINT here to avoid problems with promotions (which +** can turn a comparison between unsigneds into a signed comparison) */ -#define LUAL_BUFFERSIZE BUFSIZ +#define LUA_UNSIGNED unsigned LUAI_UACINT + + +/* now the variable definitions */ + +#if LUA_INT_TYPE == LUA_INT_INT /* { int */ + +#define LUA_INTEGER int +#define LUA_INTEGER_FRMLEN "" + +#define LUA_MAXINTEGER INT_MAX +#define LUA_MININTEGER INT_MIN + +#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ + +#define LUA_INTEGER long +#define LUA_INTEGER_FRMLEN "l" + +#define LUA_MAXINTEGER LONG_MAX +#define LUA_MININTEGER LONG_MIN + +#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ + +/* use presence of macro LLONG_MAX as proxy for C99 compliance */ +#if defined(LLONG_MAX) /* { */ +/* use ISO C99 stuff */ + +#define LUA_INTEGER long long +#define LUA_INTEGER_FRMLEN "ll" + +#define LUA_MAXINTEGER LLONG_MAX +#define LUA_MININTEGER LLONG_MIN +#elif defined(LUA_USE_WINDOWS) /* }{ */ +/* in Windows, can use specific Windows types */ +#define LUA_INTEGER __int64 +#define LUA_INTEGER_FRMLEN "I64" + +#define LUA_MAXINTEGER _I64_MAX +#define LUA_MININTEGER _I64_MIN + +#else /* }{ */ + +#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ + or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" + +#endif /* } */ + +#else /* }{ */ + +#error "numeric integer type not defined" + +#endif /* } */ + +/* }================================================================== */ /* ** {================================================================== -@@ LUA_NUMBER is the type of numbers in Lua. -** CHANGE the following definitions only if you want to build Lua -** with a number type different from double. You may also need to -** change lua_number2int & lua_number2integer. +** Dependencies with C99 and other C details ** =================================================================== */ -#define LUA_NUMBER_DOUBLE -#define LUA_NUMBER double - /* -@@ LUAI_UACNUMBER is the result of an 'usual argument conversion' -@* over a number. +@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89. +** (All uses in Lua have only one format item.) */ -#define LUAI_UACNUMBER double +#if !defined(LUA_USE_C89) +#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) +#else +#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) +#endif /* -@@ LUA_NUMBER_SCAN is the format for reading numbers. -@@ LUA_NUMBER_FMT is the format for writing numbers. -@@ lua_number2str converts a number to a string. -@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion. +@@ lua_strx2number converts an hexadecimal numeric string to a number. +** In C99, 'strtod' does that conversion. Otherwise, you can +** leave 'lua_strx2number' undefined and Lua will provide its own +** implementation. */ -#define LUA_NUMBER_SCAN "%lf" -#define LUA_NUMBER_FMT "%.14g" -#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) -#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */ +#if !defined(LUA_USE_C89) +#define lua_strx2number(s,p) lua_str2number(s,p) +#endif /* -@@ l_mathop allows the addition of an 'l' or 'f' to all math operations +@@ lua_pointer2str converts a pointer to a readable string in a +** non-specified way. */ -#define l_mathop(x) (x) +#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) /* -@@ lua_str2number converts a decimal numeric string to a number. -@@ lua_strx2number converts an hexadecimal numeric string to a number. -** In C99, 'strtod' does both conversions. C89, however, has no function -** to convert floating hexadecimal strings to numbers. For these -** systems, you can leave 'lua_strx2number' undefined and Lua will +@@ lua_number2strx converts a float to an hexadecimal numeric string. +** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that. +** Otherwise, you can leave 'lua_number2strx' undefined and Lua will ** provide its own implementation. */ -#define lua_str2number(s,p) strtod((s), (p)) - -#if defined(LUA_USE_STRTODHEX) -#define lua_strx2number(s,p) strtod((s), (p)) +#if !defined(LUA_USE_C89) +#define lua_number2strx(L,b,sz,f,n) \ + ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n))) #endif /* -@@ The luai_num* macros define the primitive operations over numbers. +** 'strtof' and 'opf' variants for math functions are not valid in +** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the +** availability of these variants. ('math.h' is already included in +** all files that use these macros.) */ - -/* the following operations need the math library */ -#if defined(lobject_c) || defined(lvm_c) -#include -#define luai_nummod(L,a,b) ((a) - l_mathop(floor)((a)/(b))*(b)) -#define luai_numpow(L,a,b) (l_mathop(pow)(a,b)) -#endif - -/* these are quite standard operations */ -#if defined(LUA_CORE) -#define luai_numadd(L,a,b) ((a)+(b)) -#define luai_numsub(L,a,b) ((a)-(b)) -#define luai_nummul(L,a,b) ((a)*(b)) -#define luai_numdiv(L,a,b) ((a)/(b)) -#define luai_numunm(L,a) (-(a)) -#define luai_numeq(a,b) ((a)==(b)) -#define luai_numlt(L,a,b) ((a)<(b)) -#define luai_numle(L,a,b) ((a)<=(b)) -#define luai_numisnan(L,a) (!luai_numeq((a), (a))) +#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) +#undef l_mathop /* variants not available */ +#undef lua_str2number +#define l_mathop(op) (lua_Number)op /* no variant */ +#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) #endif - /* -@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger. -** CHANGE that if ptrdiff_t is not adequate on your machine. (On most -** machines, ptrdiff_t gives a good choice between int or long.) +@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation +** functions. It must be a numerical type; Lua will use 'intptr_t' if +** available, otherwise it will use 'ptrdiff_t' (the nearest thing to +** 'intptr_t' in C89) */ -#define LUA_INTEGER ptrdiff_t +#define LUA_KCONTEXT ptrdiff_t + +#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ + __STDC_VERSION__ >= 199901L +#include +#if defined(INTPTR_MAX) /* even in C99 this type is optional */ +#undef LUA_KCONTEXT +#define LUA_KCONTEXT intptr_t +#endif +#endif + /* -@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned. -** It must have at least 32 bits. +@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). +** Change that if you do not want to use C locales. (Code using this +** macro must include header 'locale.h'.) */ -#define LUA_UNSIGNED unsigned LUA_INT32 +#if !defined(lua_getlocaledecpoint) +#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) +#endif +/* }================================================================== */ /* -** Some tricks with doubles +** {================================================================== +** Language Variations +** ===================================================================== */ -#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */ /* -** The next definitions activate some tricks to speed up the -** conversion from doubles to integer types, mainly to LUA_UNSIGNED. -** -@@ LUA_MSASMTRICK uses Microsoft assembler to avoid clashes with a -** DirectX idiosyncrasy. -** -@@ LUA_IEEE754TRICK uses a trick that should work on any machine -** using IEEE754 with a 32-bit integer type. -** -@@ LUA_IEEELL extends the trick to LUA_INTEGER; should only be -** defined when LUA_INTEGER is a 32-bit integer. -** -@@ LUA_IEEEENDIAN is the endianness of doubles in your machine -** (0 for little endian, 1 for big endian); if not defined, Lua will -** check it dynamically for LUA_IEEE754TRICK (but not for LUA_NANTRICK). -** -@@ LUA_NANTRICK controls the use of a trick to pack all types into -** a single double value, using NaN values to represent non-number -** values. The trick only works on 32-bit machines (ints and pointers -** are 32-bit values) with numbers represented as IEEE 754-2008 doubles -** with conventional endianess (12345678 or 87654321), in CPUs that do -** not produce signaling NaN values (all NaNs are quiet). +@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some +** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from +** numbers to strings. Define LUA_NOCVTS2N to turn off automatic +** coercion from strings to numbers. */ +/* #define LUA_NOCVTN2S */ +/* #define LUA_NOCVTS2N */ -/* Microsoft compiler on a Pentium (32 bit) ? */ -#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */ - -#define LUA_MSASMTRICK -#define LUA_IEEEENDIAN 0 -#define LUA_NANTRICK +/* +@@ LUA_USE_APICHECK turns on several consistency checks on the C API. +** Define it as a help when debugging C code. +*/ +#if defined(LUA_USE_APICHECK) +#include +#define luai_apicheck(l,e) assert(e) +#endif -/* pentium 32 bits? */ -#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */ +/* }================================================================== */ -#define LUA_IEEE754TRICK -#define LUA_IEEELL -#define LUA_IEEEENDIAN 0 -#define LUA_NANTRICK -/* pentium 64 bits? */ -#elif defined(__x86_64) /* }{ */ +/* +** {================================================================== +** Macros that affect the API and must be stable (that is, must be the +** same when you compile Lua and when you compile code that links to +** Lua). You probably do not want/need to change them. +** ===================================================================== +*/ -#define LUA_IEEE754TRICK -#define LUA_IEEEENDIAN 0 +/* +@@ LUAI_MAXSTACK limits the size of the Lua stack. +** CHANGE it if you need a different limit. This limit is arbitrary; +** its only purpose is to stop Lua from consuming unlimited stack +** space (and to reserve some numbers for pseudo-indices). +*/ +#if LUAI_BITSINT >= 32 +#define LUAI_MAXSTACK 1000000 +#else +#define LUAI_MAXSTACK 15000 +#endif -#elif defined(__POWERPC__) || defined(__ppc__) /* }{ */ -#define LUA_IEEE754TRICK -#define LUA_IEEEENDIAN 1 +/* +@@ LUA_EXTRASPACE defines the size of a raw memory area associated with +** a Lua state with very fast access. +** CHANGE it if you need a different size. +*/ +#define LUA_EXTRASPACE (sizeof(void *)) -#else /* }{ */ -/* assume IEEE754 and a 32-bit integer type */ -#define LUA_IEEE754TRICK +/* +@@ LUA_IDSIZE gives the maximum size for the description of the source +@@ of a function in debug information. +** CHANGE it if you want a different size. +*/ +#define LUA_IDSIZE 60 -#endif /* } */ -#endif /* } */ +/* +@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. +** CHANGE it if it uses too much C-stack space. (For long double, +** 'string.format("%.99f", -1e4932)' needs 5034 bytes, so a +** smaller buffer would force a memory allocation for each call to +** 'string.format'.) +*/ +#if LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE +#define LUAL_BUFFERSIZE 8192 +#else +#define LUAL_BUFFERSIZE ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer))) +#endif /* }================================================================== */ +/* +@@ LUA_QL describes how error messages quote program elements. +** Lua does not use these macros anymore; they are here for +** compatibility only. +*/ +#define LUA_QL(x) "'" x "'" +#define LUA_QS LUA_QL("%s") + + /* =================================================================== */ @@ -549,5 +797,7 @@ + + #endif diff --git a/depends/lua/include/lualib.h b/depends/lua/include/lualib.h index da82005c9d..f5304aa0dd 100644 --- a/depends/lua/include/lualib.h +++ b/depends/lua/include/lualib.h @@ -1,5 +1,5 @@ /* -** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lualib.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $ ** Lua standard libraries ** See Copyright Notice in lua.h */ @@ -11,6 +11,9 @@ #include "lua.h" +/* version suffix for environment variable names */ +#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR + LUAMOD_API int (luaopen_base) (lua_State *L); @@ -29,6 +32,9 @@ LUAMOD_API int (luaopen_os) (lua_State *L); #define LUA_STRLIBNAME "string" LUAMOD_API int (luaopen_string) (lua_State *L); +#define LUA_UTF8LIBNAME "utf8" +LUAMOD_API int (luaopen_utf8) (lua_State *L); + #define LUA_BITLIBNAME "bit32" LUAMOD_API int (luaopen_bit32) (lua_State *L); diff --git a/depends/lua/include/lundump.h b/depends/lua/include/lundump.h index 5255db259d..ce492d689c 100644 --- a/depends/lua/include/lundump.h +++ b/depends/lua/include/lundump.h @@ -1,5 +1,5 @@ /* -** $Id: lundump.h,v 1.39.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lundump.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $ ** load precompiled Lua chunks ** See Copyright Notice in lua.h */ @@ -7,22 +7,26 @@ #ifndef lundump_h #define lundump_h +#include "llimits.h" #include "lobject.h" #include "lzio.h" -/* load one chunk; from lundump.c */ -LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name); -/* make header; from lundump.c */ -LUAI_FUNC void luaU_header (lu_byte* h); +/* data to catch conversion errors */ +#define LUAC_DATA "\x19\x93\r\n\x1a\n" -/* dump one chunk; from ldump.c */ -LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip); +#define LUAC_INT 0x5678 +#define LUAC_NUM cast_num(370.5) -/* data to catch conversion errors */ -#define LUAC_TAIL "\x19\x93\r\n\x1a\n" +#define MYINT(s) (s[0]-'0') +#define LUAC_VERSION (MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR)) +#define LUAC_FORMAT 0 /* this is the official format */ -/* size in bytes of header of binary files */ -#define LUAC_HEADERSIZE (sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char)) +/* load one chunk; from lundump.c */ +LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name); + +/* dump one chunk; from ldump.c */ +LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, + void* data, int strip); #endif diff --git a/depends/lua/include/lvm.h b/depends/lua/include/lvm.h index 5380270da6..a8f954f04c 100644 --- a/depends/lua/include/lvm.h +++ b/depends/lua/include/lvm.h @@ -1,5 +1,5 @@ /* -** $Id: lvm.h,v 2.18.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lvm.h,v 2.41.1.1 2017/04/19 17:20:42 roberto Exp $ ** Lua virtual machine ** See Copyright Notice in lua.h */ @@ -13,32 +13,101 @@ #include "ltm.h" -#define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o))) +#if !defined(LUA_NOCVTN2S) +#define cvt2str(o) ttisnumber(o) +#else +#define cvt2str(o) 0 /* no conversion from numbers to strings */ +#endif + + +#if !defined(LUA_NOCVTS2N) +#define cvt2num(o) ttisstring(o) +#else +#define cvt2num(o) 0 /* no conversion from strings to numbers */ +#endif + + +/* +** You can define LUA_FLOORN2I if you want to convert floats to integers +** by flooring them (instead of raising an error if they are not +** integral values) +*/ +#if !defined(LUA_FLOORN2I) +#define LUA_FLOORN2I 0 +#endif + + +#define tonumber(o,n) \ + (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) + +#define tointeger(o,i) \ + (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I)) -#define tonumber(o,n) (ttisnumber(o) || (((o) = luaV_tonumber(o,n)) != NULL)) +#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) -#define equalobj(L,o1,o2) (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2)) +#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) + + +/* +** fast track for 'gettable': if 't' is a table and 't[k]' is not nil, +** return 1 with 'slot' pointing to 't[k]' (final result). Otherwise, +** return 0 (meaning it will have to check metamethod) with 'slot' +** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise). +** 'f' is the raw get function to use. +*/ +#define luaV_fastget(L,t,k,slot,f) \ + (!ttistable(t) \ + ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ + : (slot = f(hvalue(t), k), /* else, do raw access */ \ + !ttisnil(slot))) /* result not nil? */ + +/* +** standard implementation for 'gettable' +*/ +#define luaV_gettable(L,t,k,v) { const TValue *slot; \ + if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \ + else luaV_finishget(L,t,k,v,slot); } + + +/* +** Fast track for set table. If 't' is a table and 't[k]' is not nil, +** call GC barrier, do a raw 't[k]=v', and return true; otherwise, +** return false with 'slot' equal to NULL (if 't' is not a table) or +** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro +** returns true, there is no need to 'invalidateTMcache', because the +** call is not creating a new entry. +*/ +#define luaV_fastset(L,t,k,slot,f,v) \ + (!ttistable(t) \ + ? (slot = NULL, 0) \ + : (slot = f(hvalue(t), k), \ + ttisnil(slot) ? 0 \ + : (luaC_barrierback(L, hvalue(t), v), \ + setobj2t(L, cast(TValue *,slot), v), \ + 1))) -#define luaV_rawequalobj(o1,o2) equalobj(NULL,o1,o2) +#define luaV_settable(L,t,k,v) { const TValue *slot; \ + if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \ + luaV_finishset(L,t,k,v,slot); } -/* not to called directly */ -LUAI_FUNC int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2); +LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2); LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r); LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r); -LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n); -LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj); -LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key, - StkId val); -LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key, - StkId val); +LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n); +LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode); +LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key, + StkId val, const TValue *slot); +LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key, + StkId val, const TValue *slot); LUAI_FUNC void luaV_finishOp (lua_State *L); LUAI_FUNC void luaV_execute (lua_State *L); LUAI_FUNC void luaV_concat (lua_State *L, int total); -LUAI_FUNC void luaV_arith (lua_State *L, StkId ra, const TValue *rb, - const TValue *rc, TMS op); +LUAI_FUNC lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y); +LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y); +LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y); LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb); #endif diff --git a/depends/lua/include/lzio.h b/depends/lua/include/lzio.h index 441f7479cb..d897870815 100644 --- a/depends/lua/include/lzio.h +++ b/depends/lua/include/lzio.h @@ -1,5 +1,5 @@ /* -** $Id: lzio.h,v 1.26.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lzio.h,v 1.31.1.1 2017/04/19 17:20:42 roberto Exp $ ** Buffered streams ** See Copyright Notice in lua.h */ @@ -32,20 +32,21 @@ typedef struct Mbuffer { #define luaZ_sizebuffer(buff) ((buff)->buffsize) #define luaZ_bufflen(buff) ((buff)->n) +#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) #define luaZ_resetbuffer(buff) ((buff)->n = 0) #define luaZ_resizebuffer(L, buff, size) \ - (luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \ + ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ + (buff)->buffsize, size), \ (buff)->buffsize = size) #define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) -LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n); LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data); -LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */ +LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n); /* read next n bytes */ @@ -55,7 +56,7 @@ struct Zio { size_t n; /* bytes still unread */ const char *p; /* current position in buffer */ lua_Reader reader; /* reader function */ - void* data; /* additional data */ + void *data; /* additional data */ lua_State *L; /* Lua state (for reader) */ }; diff --git a/depends/lua/src/lapi.c b/depends/lua/src/lapi.c index d011431ead..aa01148ab1 100644 --- a/depends/lua/src/lapi.c +++ b/depends/lua/src/lapi.c @@ -1,16 +1,18 @@ /* -** $Id: lapi.c,v 2.171.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lapi.c,v 2.259.1.2 2017/12/06 18:35:12 roberto Exp $ ** Lua API ** See Copyright Notice in lua.h */ +#define lapi_c +#define LUA_CORE + +#include "lprefix.h" + #include #include -#define lapi_c -#define LUA_CORE - #include "lua.h" #include "lapi.h" @@ -43,13 +45,16 @@ const char lua_ident[] = /* test for pseudo index */ #define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) +/* test for upvalue */ +#define isupvalue(i) ((i) < LUA_REGISTRYINDEX) + /* test for valid but not pseudo index */ #define isstackindex(i, o) (isvalid(o) && !ispseudo(i)) -#define api_checkvalidindex(L, o) api_check(L, isvalid(o), "invalid index") +#define api_checkvalidindex(l,o) api_check(l, isvalid(o), "invalid index") -#define api_checkstackindex(L, i, o) \ - api_check(L, isstackindex(i, o), "index not in the stack") +#define api_checkstackindex(l, i, o) \ + api_check(l, isstackindex(i, o), "index not in the stack") static TValue *index2addr (lua_State *L, int idx) { @@ -89,21 +94,22 @@ static void growstack (lua_State *L, void *ud) { } -LUA_API int lua_checkstack (lua_State *L, int size) { +LUA_API int lua_checkstack (lua_State *L, int n) { int res; CallInfo *ci = L->ci; lua_lock(L); - if (L->stack_last - L->top > size) /* stack large enough? */ + api_check(L, n >= 0, "negative 'n'"); + if (L->stack_last - L->top > n) /* stack large enough? */ res = 1; /* yes; check is OK */ else { /* no; need to grow stack */ int inuse = cast_int(L->top - L->stack) + EXTRA_STACK; - if (inuse > LUAI_MAXSTACK - size) /* can grow without overflow? */ + if (inuse > LUAI_MAXSTACK - n) /* can grow without overflow? */ res = 0; /* no */ else /* try to grow stack */ - res = (luaD_rawrunprotected(L, &growstack, &size) == LUA_OK); + res = (luaD_rawrunprotected(L, &growstack, &n) == LUA_OK); } - if (res && ci->top < L->top + size) - ci->top = L->top + size; /* adjust frame top */ + if (res && ci->top < L->top + n) + ci->top = L->top + n; /* adjust frame top */ lua_unlock(L); return res; } @@ -115,10 +121,11 @@ LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) { lua_lock(to); api_checknelems(from, n); api_check(from, G(from) == G(to), "moving among independent states"); - api_check(from, to->ci->top - to->top >= n, "not enough elements to move"); + api_check(from, to->ci->top - to->top >= n, "stack overflow"); from->top -= n; for (i = 0; i < n; i++) { - setobj2s(to, to->top++, from->top + i); + setobj2s(to, to->top, from->top + i); + to->top++; /* stack already checked by previous 'api_check' */ } lua_unlock(to); } @@ -153,7 +160,7 @@ LUA_API const lua_Number *lua_version (lua_State *L) { LUA_API int lua_absindex (lua_State *L, int idx) { return (idx > 0 || ispseudo(idx)) ? idx - : cast_int(L->top - L->ci->func + idx); + : cast_int(L->top - L->ci->func) + idx; } @@ -173,61 +180,56 @@ LUA_API void lua_settop (lua_State *L, int idx) { } else { api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top"); - L->top += idx+1; /* `subtract' index (index is negative) */ + L->top += idx+1; /* 'subtract' index (index is negative) */ } lua_unlock(L); } -LUA_API void lua_remove (lua_State *L, int idx) { - StkId p; - lua_lock(L); - p = index2addr(L, idx); - api_checkstackindex(L, idx, p); - while (++p < L->top) setobjs2s(L, p-1, p); - L->top--; - lua_unlock(L); +/* +** Reverse the stack segment from 'from' to 'to' +** (auxiliary to 'lua_rotate') +*/ +static void reverse (lua_State *L, StkId from, StkId to) { + for (; from < to; from++, to--) { + TValue temp; + setobj(L, &temp, from); + setobjs2s(L, from, to); + setobj2s(L, to, &temp); + } } -LUA_API void lua_insert (lua_State *L, int idx) { - StkId p; - StkId q; +/* +** Let x = AB, where A is a prefix of length 'n'. Then, +** rotate x n == BA. But BA == (A^r . B^r)^r. +*/ +LUA_API void lua_rotate (lua_State *L, int idx, int n) { + StkId p, t, m; lua_lock(L); - p = index2addr(L, idx); + t = L->top - 1; /* end of stack segment being rotated */ + p = index2addr(L, idx); /* start of segment */ api_checkstackindex(L, idx, p); - for (q = L->top; q > p; q--) /* use L->top as a temporary */ - setobjs2s(L, q, q - 1); - setobjs2s(L, p, L->top); + api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'"); + m = (n >= 0 ? t - n : p - n - 1); /* end of prefix */ + reverse(L, p, m); /* reverse the prefix with length 'n' */ + reverse(L, m + 1, t); /* reverse the suffix */ + reverse(L, p, t); /* reverse the entire segment */ lua_unlock(L); } -static void moveto (lua_State *L, TValue *fr, int idx) { - TValue *to = index2addr(L, idx); +LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) { + TValue *fr, *to; + lua_lock(L); + fr = index2addr(L, fromidx); + to = index2addr(L, toidx); api_checkvalidindex(L, to); setobj(L, to, fr); - if (idx < LUA_REGISTRYINDEX) /* function upvalue? */ + if (isupvalue(toidx)) /* function upvalue? */ luaC_barrier(L, clCvalue(L->ci->func), fr); /* LUA_REGISTRYINDEX does not need gc barrier (collector revisits it before finishing collection) */ -} - - -LUA_API void lua_replace (lua_State *L, int idx) { - lua_lock(L); - api_checknelems(L, 1); - moveto(L, L->top - 1, idx); - L->top--; - lua_unlock(L); -} - - -LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) { - TValue *fr; - lua_lock(L); - fr = index2addr(L, fromidx); - moveto(L, fr, toidx); lua_unlock(L); } @@ -248,12 +250,13 @@ LUA_API void lua_pushvalue (lua_State *L, int idx) { LUA_API int lua_type (lua_State *L, int idx) { StkId o = index2addr(L, idx); - return (isvalid(o) ? ttypenv(o) : LUA_TNONE); + return (isvalid(o) ? ttnov(o) : LUA_TNONE); } LUA_API const char *lua_typename (lua_State *L, int t) { UNUSED(L); + api_check(L, LUA_TNONE <= t && t < LUA_NUMTAGS, "invalid tag"); return ttypename(t); } @@ -264,22 +267,28 @@ LUA_API int lua_iscfunction (lua_State *L, int idx) { } +LUA_API int lua_isinteger (lua_State *L, int idx) { + StkId o = index2addr(L, idx); + return ttisinteger(o); +} + + LUA_API int lua_isnumber (lua_State *L, int idx) { - TValue n; + lua_Number n; const TValue *o = index2addr(L, idx); return tonumber(o, &n); } LUA_API int lua_isstring (lua_State *L, int idx) { - int t = lua_type(L, idx); - return (t == LUA_TSTRING || t == LUA_TNUMBER); + const TValue *o = index2addr(L, idx); + return (ttisstring(o) || cvt2str(o)); } LUA_API int lua_isuserdata (lua_State *L, int idx) { const TValue *o = index2addr(L, idx); - return (ttisuserdata(o) || ttislightuserdata(o)); + return (ttisfulluserdata(o) || ttislightuserdata(o)); } @@ -291,24 +300,17 @@ LUA_API int lua_rawequal (lua_State *L, int index1, int index2) { LUA_API void lua_arith (lua_State *L, int op) { - StkId o1; /* 1st operand */ - StkId o2; /* 2nd operand */ lua_lock(L); - if (op != LUA_OPUNM) /* all other operations expect two operands */ - api_checknelems(L, 2); - else { /* for unary minus, add fake 2nd operand */ + if (op != LUA_OPUNM && op != LUA_OPBNOT) + api_checknelems(L, 2); /* all other operations expect two operands */ + else { /* for unary operations, add fake 2nd operand */ api_checknelems(L, 1); setobjs2s(L, L->top, L->top - 1); - L->top++; - } - o1 = L->top - 2; - o2 = L->top - 1; - if (ttisnumber(o1) && ttisnumber(o2)) { - setnvalue(o1, luaO_arith(op, nvalue(o1), nvalue(o2))); + api_incr_top(L); } - else - luaV_arith(L, o1, o1, o2, cast(TMS, op - LUA_OPADD + TM_ADD)); - L->top--; + /* first operand at top - 2, second at top - 1; result go to top - 2 */ + luaO_arith(L, op, L->top - 2, L->top - 1, L->top - 2); + L->top--; /* remove second operand */ lua_unlock(L); } @@ -321,7 +323,7 @@ LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) { o2 = index2addr(L, index2); if (isvalid(o1) && isvalid(o2)) { switch (op) { - case LUA_OPEQ: i = equalobj(L, o1, o2); break; + case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break; case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break; case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break; default: api_check(L, 0, "invalid option"); @@ -332,51 +334,33 @@ LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) { } -LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *isnum) { - TValue n; - const TValue *o = index2addr(L, idx); - if (tonumber(o, &n)) { - if (isnum) *isnum = 1; - return nvalue(o); - } - else { - if (isnum) *isnum = 0; - return 0; - } +LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) { + size_t sz = luaO_str2num(s, L->top); + if (sz != 0) + api_incr_top(L); + return sz; } -LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *isnum) { - TValue n; +LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) { + lua_Number n; const TValue *o = index2addr(L, idx); - if (tonumber(o, &n)) { - lua_Integer res; - lua_Number num = nvalue(o); - lua_number2integer(res, num); - if (isnum) *isnum = 1; - return res; - } - else { - if (isnum) *isnum = 0; - return 0; - } + int isnum = tonumber(o, &n); + if (!isnum) + n = 0; /* call to 'tonumber' may change 'n' even if it fails */ + if (pisnum) *pisnum = isnum; + return n; } -LUA_API lua_Unsigned lua_tounsignedx (lua_State *L, int idx, int *isnum) { - TValue n; +LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) { + lua_Integer res; const TValue *o = index2addr(L, idx); - if (tonumber(o, &n)) { - lua_Unsigned res; - lua_Number num = nvalue(o); - lua_number2unsigned(res, num); - if (isnum) *isnum = 1; - return res; - } - else { - if (isnum) *isnum = 0; - return 0; - } + int isnum = tointeger(o, &res); + if (!isnum) + res = 0; /* call to 'tointeger' may change 'n' even if it fails */ + if (pisnum) *pisnum = isnum; + return res; } @@ -389,27 +373,29 @@ LUA_API int lua_toboolean (lua_State *L, int idx) { LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { StkId o = index2addr(L, idx); if (!ttisstring(o)) { - lua_lock(L); /* `luaV_tostring' may create a new string */ - if (!luaV_tostring(L, o)) { /* conversion failed? */ + if (!cvt2str(o)) { /* not convertible? */ if (len != NULL) *len = 0; - lua_unlock(L); return NULL; } + lua_lock(L); /* 'luaO_tostring' may create a new string */ + luaO_tostring(L, o); luaC_checkGC(L); o = index2addr(L, idx); /* previous call may reallocate the stack */ lua_unlock(L); } - if (len != NULL) *len = tsvalue(o)->len; + if (len != NULL) + *len = vslen(o); return svalue(o); } LUA_API size_t lua_rawlen (lua_State *L, int idx) { StkId o = index2addr(L, idx); - switch (ttypenv(o)) { - case LUA_TSTRING: return tsvalue(o)->len; + switch (ttype(o)) { + case LUA_TSHRSTR: return tsvalue(o)->shrlen; + case LUA_TLNGSTR: return tsvalue(o)->u.lnglen; case LUA_TUSERDATA: return uvalue(o)->len; - case LUA_TTABLE: return luaH_getn(hvalue(o)); + case LUA_TTABLE: return size_t(luaH_getn(hvalue(o))); default: return 0; } } @@ -426,8 +412,8 @@ LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) { LUA_API void *lua_touserdata (lua_State *L, int idx) { StkId o = index2addr(L, idx); - switch (ttypenv(o)) { - case LUA_TUSERDATA: return (rawuvalue(o) + 1); + switch (ttnov(o)) { + case LUA_TUSERDATA: return getudatamem(uvalue(o)); case LUA_TLIGHTUSERDATA: return pvalue(o); default: return NULL; } @@ -448,9 +434,8 @@ LUA_API const void *lua_topointer (lua_State *L, int idx) { case LUA_TCCL: return clCvalue(o); case LUA_TLCF: return cast(void *, cast(size_t, fvalue(o))); case LUA_TTHREAD: return thvalue(o); - case LUA_TUSERDATA: - case LUA_TLIGHTUSERDATA: - return lua_touserdata(L, idx); + case LUA_TUSERDATA: return getudatamem(uvalue(o)); + case LUA_TLIGHTUSERDATA: return pvalue(o); default: return NULL; } } @@ -472,9 +457,7 @@ LUA_API void lua_pushnil (lua_State *L) { LUA_API void lua_pushnumber (lua_State *L, lua_Number n) { lua_lock(L); - setnvalue(L->top, n); - luai_checknum(L, L->top, - luaG_runerror(L, "C API - attempt to push a signaling NaN")); + setfltvalue(L->top, n); api_incr_top(L); lua_unlock(L); } @@ -482,49 +465,43 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) { LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) { lua_lock(L); - setnvalue(L->top, cast_num(n)); - api_incr_top(L); - lua_unlock(L); -} - - -LUA_API void lua_pushunsigned (lua_State *L, lua_Unsigned u) { - lua_Number n; - lua_lock(L); - n = lua_unsigned2number(u); - setnvalue(L->top, n); + setivalue(L->top, n); api_incr_top(L); lua_unlock(L); } +/* +** Pushes on the stack a string with given length. Avoid using 's' when +** 'len' == 0 (as 's' can be NULL in that case), due to later use of +** 'memcmp' and 'memcpy'. +*/ LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) { TString *ts; lua_lock(L); - luaC_checkGC(L); - ts = luaS_newlstr(L, s, len); + ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len); setsvalue2s(L, L->top, ts); api_incr_top(L); + luaC_checkGC(L); lua_unlock(L); return getstr(ts); } LUA_API const char *lua_pushstring (lua_State *L, const char *s) { - if (s == NULL) { - lua_pushnil(L); - return NULL; - } + lua_lock(L); + if (s == NULL) + setnilvalue(L->top); else { TString *ts; - lua_lock(L); - luaC_checkGC(L); ts = luaS_new(L, s); setsvalue2s(L, L->top, ts); - api_incr_top(L); - lua_unlock(L); - return getstr(ts); + s = getstr(ts); /* internal copy's address */ } + api_incr_top(L); + luaC_checkGC(L); + lua_unlock(L); + return s; } @@ -532,8 +509,8 @@ LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt, va_list argp) { const char *ret; lua_lock(L); - luaC_checkGC(L); ret = luaO_pushvfstring(L, fmt, argp); + luaC_checkGC(L); lua_unlock(L); return ret; } @@ -543,10 +520,10 @@ LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { const char *ret; va_list argp; lua_lock(L); - luaC_checkGC(L); va_start(argp, fmt); ret = luaO_pushvfstring(L, fmt, argp); va_end(argp); + luaC_checkGC(L); lua_unlock(L); return ret; } @@ -556,20 +533,23 @@ LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { lua_lock(L); if (n == 0) { setfvalue(L->top, fn); + api_incr_top(L); } else { - Closure *cl; + CClosure *cl; api_checknelems(L, n); api_check(L, n <= MAXUPVAL, "upvalue index too large"); - luaC_checkGC(L); cl = luaF_newCclosure(L, n); - cl->c.f = fn; + cl->f = fn; L->top -= n; - while (n--) - setobj2n(L, &cl->c.upvalue[n], L->top + n); + while (n--) { + setobj2n(L, &cl->upvalue[n], L->top + n); + /* does not need barrier because closure is white */ + } setclCvalue(L, L->top, cl); + api_incr_top(L); + luaC_checkGC(L); } - api_incr_top(L); lua_unlock(L); } @@ -605,48 +585,77 @@ LUA_API int lua_pushthread (lua_State *L) { */ -LUA_API void lua_getglobal (lua_State *L, const char *var) { +static int auxgetstr (lua_State *L, const TValue *t, const char *k) { + const TValue *slot; + TString *str = luaS_new(L, k); + if (luaV_fastget(L, t, str, slot, luaH_getstr)) { + setobj2s(L, L->top, slot); + api_incr_top(L); + } + else { + setsvalue2s(L, L->top, str); + api_incr_top(L); + luaV_finishget(L, t, L->top - 1, L->top - 1, slot); + } + lua_unlock(L); + return ttnov(L->top - 1); +} + + +LUA_API int lua_getglobal (lua_State *L, const char *name) { Table *reg = hvalue(&G(L)->l_registry); - const TValue *gt; /* global table */ lua_lock(L); - gt = luaH_getint(reg, LUA_RIDX_GLOBALS); - setsvalue2s(L, L->top++, luaS_new(L, var)); - luaV_gettable(L, gt, L->top - 1, L->top - 1); - lua_unlock(L); + return auxgetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name); } -LUA_API void lua_gettable (lua_State *L, int idx) { +LUA_API int lua_gettable (lua_State *L, int idx) { StkId t; lua_lock(L); t = index2addr(L, idx); luaV_gettable(L, t, L->top - 1, L->top - 1); lua_unlock(L); + return ttnov(L->top - 1); +} + + +LUA_API int lua_getfield (lua_State *L, int idx, const char *k) { + lua_lock(L); + return auxgetstr(L, index2addr(L, idx), k); } -LUA_API void lua_getfield (lua_State *L, int idx, const char *k) { +LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) { StkId t; + const TValue *slot; lua_lock(L); t = index2addr(L, idx); - setsvalue2s(L, L->top, luaS_new(L, k)); - api_incr_top(L); - luaV_gettable(L, t, L->top - 1, L->top - 1); + if (luaV_fastget(L, t, n, slot, luaH_getint)) { + setobj2s(L, L->top, slot); + api_incr_top(L); + } + else { + setivalue(L->top, n); + api_incr_top(L); + luaV_finishget(L, t, L->top - 1, L->top - 1, slot); + } lua_unlock(L); + return ttnov(L->top - 1); } -LUA_API void lua_rawget (lua_State *L, int idx) { +LUA_API int lua_rawget (lua_State *L, int idx) { StkId t; lua_lock(L); t = index2addr(L, idx); api_check(L, ttistable(t), "table expected"); setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1)); lua_unlock(L); + return ttnov(L->top - 1); } -LUA_API void lua_rawgeti (lua_State *L, int idx, int n) { +LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) { StkId t; lua_lock(L); t = index2addr(L, idx); @@ -654,10 +663,11 @@ LUA_API void lua_rawgeti (lua_State *L, int idx, int n) { setobj2s(L, L->top, luaH_getint(hvalue(t), n)); api_incr_top(L); lua_unlock(L); + return ttnov(L->top - 1); } -LUA_API void lua_rawgetp (lua_State *L, int idx, const void *p) { +LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) { StkId t; TValue k; lua_lock(L); @@ -667,29 +677,30 @@ LUA_API void lua_rawgetp (lua_State *L, int idx, const void *p) { setobj2s(L, L->top, luaH_get(hvalue(t), &k)); api_incr_top(L); lua_unlock(L); + return ttnov(L->top - 1); } LUA_API void lua_createtable (lua_State *L, int narray, int nrec) { Table *t; lua_lock(L); - luaC_checkGC(L); t = luaH_new(L); sethvalue(L, L->top, t); api_incr_top(L); if (narray > 0 || nrec > 0) luaH_resize(L, t, narray, nrec); + luaC_checkGC(L); lua_unlock(L); } LUA_API int lua_getmetatable (lua_State *L, int objindex) { const TValue *obj; - Table *mt = NULL; - int res; + Table *mt; + int res = 0; lua_lock(L); obj = index2addr(L, objindex); - switch (ttypenv(obj)) { + switch (ttnov(obj)) { case LUA_TTABLE: mt = hvalue(obj)->metatable; break; @@ -697,12 +708,10 @@ LUA_API int lua_getmetatable (lua_State *L, int objindex) { mt = uvalue(obj)->metatable; break; default: - mt = G(L)->mt[ttypenv(obj)]; + mt = G(L)->mt[ttnov(obj)]; break; } - if (mt == NULL) - res = 0; - else { + if (mt != NULL) { sethvalue(L, L->top, mt); api_incr_top(L); res = 1; @@ -712,17 +721,15 @@ LUA_API int lua_getmetatable (lua_State *L, int objindex) { } -LUA_API void lua_getuservalue (lua_State *L, int idx) { +LUA_API int lua_getuservalue (lua_State *L, int idx) { StkId o; lua_lock(L); o = index2addr(L, idx); - api_check(L, ttisuserdata(o), "userdata expected"); - if (uvalue(o)->env) { - sethvalue(L, L->top, uvalue(o)->env); - } else - setnilvalue(L->top); + api_check(L, ttisfulluserdata(o), "full userdata expected"); + getuservalue(L, uvalue(o), L->top); api_incr_top(L); lua_unlock(L); + return ttnov(L->top - 1); } @@ -730,17 +737,29 @@ LUA_API void lua_getuservalue (lua_State *L, int idx) { ** set functions (stack -> Lua) */ +/* +** t[k] = value at the top of the stack (where 'k' is a string) +*/ +static void auxsetstr (lua_State *L, const TValue *t, const char *k) { + const TValue *slot; + TString *str = luaS_new(L, k); + api_checknelems(L, 1); + if (luaV_fastset(L, t, str, slot, luaH_getstr, L->top - 1)) + L->top--; /* pop value */ + else { + setsvalue2s(L, L->top, str); /* push 'str' (to make it a TValue) */ + api_incr_top(L); + luaV_finishset(L, t, L->top - 1, L->top - 2, slot); + L->top -= 2; /* pop value and key */ + } + lua_unlock(L); /* lock done by caller */ +} + -LUA_API void lua_setglobal (lua_State *L, const char *var) { +LUA_API void lua_setglobal (lua_State *L, const char *name) { Table *reg = hvalue(&G(L)->l_registry); - const TValue *gt; /* global table */ - lua_lock(L); - api_checknelems(L, 1); - gt = luaH_getint(reg, LUA_RIDX_GLOBALS); - setsvalue2s(L, L->top++, luaS_new(L, var)); - luaV_settable(L, gt, L->top - 1, L->top - 2); - L->top -= 2; /* pop value and key */ - lua_unlock(L); + lua_lock(L); /* unlock done in 'auxsetstr' */ + auxsetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name); } @@ -756,54 +775,69 @@ LUA_API void lua_settable (lua_State *L, int idx) { LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { + lua_lock(L); /* unlock done in 'auxsetstr' */ + auxsetstr(L, index2addr(L, idx), k); +} + + +LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) { StkId t; + const TValue *slot; lua_lock(L); api_checknelems(L, 1); t = index2addr(L, idx); - setsvalue2s(L, L->top++, luaS_new(L, k)); - luaV_settable(L, t, L->top - 1, L->top - 2); - L->top -= 2; /* pop value and key */ + if (luaV_fastset(L, t, n, slot, luaH_getint, L->top - 1)) + L->top--; /* pop value */ + else { + setivalue(L->top, n); + api_incr_top(L); + luaV_finishset(L, t, L->top - 1, L->top - 2, slot); + L->top -= 2; /* pop value and key */ + } lua_unlock(L); } LUA_API void lua_rawset (lua_State *L, int idx) { - StkId t; + StkId o; + TValue *slot; lua_lock(L); api_checknelems(L, 2); - t = index2addr(L, idx); - api_check(L, ttistable(t), "table expected"); - setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1); - invalidateTMcache(hvalue(t)); - luaC_barrierback(L, gcvalue(t), L->top-1); + o = index2addr(L, idx); + api_check(L, ttistable(o), "table expected"); + slot = luaH_set(L, hvalue(o), L->top - 2); + setobj2t(L, slot, L->top - 1); + invalidateTMcache(hvalue(o)); + luaC_barrierback(L, hvalue(o), L->top-1); L->top -= 2; lua_unlock(L); } -LUA_API void lua_rawseti (lua_State *L, int idx, int n) { - StkId t; +LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) { + StkId o; lua_lock(L); api_checknelems(L, 1); - t = index2addr(L, idx); - api_check(L, ttistable(t), "table expected"); - luaH_setint(L, hvalue(t), n, L->top - 1); - luaC_barrierback(L, gcvalue(t), L->top-1); + o = index2addr(L, idx); + api_check(L, ttistable(o), "table expected"); + luaH_setint(L, hvalue(o), n, L->top - 1); + luaC_barrierback(L, hvalue(o), L->top-1); L->top--; lua_unlock(L); } LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) { - StkId t; - TValue k; + StkId o; + TValue k, *slot; lua_lock(L); api_checknelems(L, 1); - t = index2addr(L, idx); - api_check(L, ttistable(t), "table expected"); + o = index2addr(L, idx); + api_check(L, ttistable(o), "table expected"); setpvalue(&k, cast(void *, p)); - setobj2t(L, luaH_set(L, hvalue(t), &k), L->top - 1); - luaC_barrierback(L, gcvalue(t), L->top - 1); + slot = luaH_set(L, hvalue(o), &k); + setobj2t(L, slot, L->top - 1); + luaC_barrierback(L, hvalue(o), L->top - 1); L->top--; lua_unlock(L); } @@ -821,11 +855,11 @@ LUA_API int lua_setmetatable (lua_State *L, int objindex) { api_check(L, ttistable(L->top - 1), "table expected"); mt = hvalue(L->top - 1); } - switch (ttypenv(obj)) { + switch (ttnov(obj)) { case LUA_TTABLE: { hvalue(obj)->metatable = mt; if (mt) { - luaC_objbarrierback(L, gcvalue(obj), mt); + luaC_objbarrier(L, gcvalue(obj), mt); luaC_checkfinalizer(L, gcvalue(obj), mt); } break; @@ -833,13 +867,13 @@ LUA_API int lua_setmetatable (lua_State *L, int objindex) { case LUA_TUSERDATA: { uvalue(obj)->metatable = mt; if (mt) { - luaC_objbarrier(L, rawuvalue(obj), mt); + luaC_objbarrier(L, uvalue(obj), mt); luaC_checkfinalizer(L, gcvalue(obj), mt); } break; } default: { - G(L)->mt[ttypenv(obj)] = mt; + G(L)->mt[ttnov(obj)] = mt; break; } } @@ -854,21 +888,16 @@ LUA_API void lua_setuservalue (lua_State *L, int idx) { lua_lock(L); api_checknelems(L, 1); o = index2addr(L, idx); - api_check(L, ttisuserdata(o), "userdata expected"); - if (ttisnil(L->top - 1)) - uvalue(o)->env = NULL; - else { - api_check(L, ttistable(L->top - 1), "table expected"); - uvalue(o)->env = hvalue(L->top - 1); - luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1)); - } + api_check(L, ttisfulluserdata(o), "full userdata expected"); + setuservalue(L, uvalue(o), L->top - 1); + luaC_barrier(L, gcvalue(o), L->top - 1); L->top--; lua_unlock(L); } /* -** `load' and `call' functions (run Lua code) +** 'load' and 'call' functions (run Lua code) */ @@ -877,17 +906,8 @@ LUA_API void lua_setuservalue (lua_State *L, int idx) { "results from function overflow current stack size") -LUA_API int lua_getctx (lua_State *L, int *ctx) { - if (L->ci->callstatus & CIST_YIELDED) { - if (ctx) *ctx = L->ci->u.c.ctx; - return L->ci->u.c.status; - } - else return LUA_OK; -} - - -LUA_API void lua_callk (lua_State *L, int nargs, int nresults, int ctx, - lua_CFunction k) { +LUA_API void lua_callk (lua_State *L, int nargs, int nresults, + lua_KContext ctx, lua_KFunction k) { StkId func; lua_lock(L); api_check(L, k == NULL || !isLua(L->ci), @@ -899,10 +919,10 @@ LUA_API void lua_callk (lua_State *L, int nargs, int nresults, int ctx, if (k != NULL && L->nny == 0) { /* need to prepare continuation? */ L->ci->u.c.k = k; /* save continuation */ L->ci->u.c.ctx = ctx; /* save context */ - luaD_call(L, func, nresults, 1); /* do the call */ + luaD_call(L, func, nresults); /* do the call */ } else /* no continuation or no yieldable */ - luaD_call(L, func, nresults, 0); /* just do the call */ + luaD_callnoyield(L, func, nresults); /* just do the call */ adjustresults(L, nresults); lua_unlock(L); } @@ -912,7 +932,7 @@ LUA_API void lua_callk (lua_State *L, int nargs, int nresults, int ctx, /* ** Execute a protected call. */ -struct CallS { /* data to `f_call' */ +struct CallS { /* data to 'f_call' */ StkId func; int nresults; }; @@ -920,13 +940,13 @@ struct CallS { /* data to `f_call' */ static void f_call (lua_State *L, void *ud) { struct CallS *c = cast(struct CallS *, ud); - luaD_call(L, c->func, c->nresults, 0); + luaD_callnoyield(L, c->func, c->nresults); } LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc, - int ctx, lua_CFunction k) { + lua_KContext ctx, lua_KFunction k) { struct CallS c; int status; ptrdiff_t func; @@ -954,12 +974,11 @@ LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc, ci->u.c.ctx = ctx; /* save context */ /* save information for error recovery */ ci->extra = savestack(L, c.func); - ci->u.c.old_allowhook = L->allowhook; ci->u.c.old_errfunc = L->errfunc; L->errfunc = func; - /* mark that function may do error recovery */ - ci->callstatus |= CIST_YPCALL; - luaD_call(L, c.func, nresults, 1); /* do the call */ + setoah(ci->callstatus, L->allowhook); /* save value of 'allowhook' */ + ci->callstatus |= CIST_YPCALL; /* function can do error recovery */ + luaD_call(L, c.func, nresults); /* do the call */ ci->callstatus &= ~CIST_YPCALL; L->errfunc = ci->u.c.old_errfunc; status = LUA_OK; /* if it is here, there were no errors */ @@ -980,13 +999,13 @@ LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data, status = luaD_protectedparser(L, &z, chunkname, mode); if (status == LUA_OK) { /* no errors? */ LClosure *f = clLvalue(L->top - 1); /* get newly created function */ - if (f->nupvalues == 1) { /* does it have one upvalue? */ + if (f->nupvalues >= 1) { /* does it have an upvalue? */ /* get global table from registry */ Table *reg = hvalue(&G(L)->l_registry); const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS); /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */ setobj(L, f->upvals[0]->v, gt); - luaC_barrier(L, f->upvals[0], gt); + luaC_upvalbarrier(L, f->upvals[0]); } } lua_unlock(L); @@ -994,14 +1013,14 @@ LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data, } -LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) { +LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) { int status; TValue *o; lua_lock(L); api_checknelems(L, 1); o = L->top - 1; if (isLfunction(o)) - status = luaU_dump(L, getproto(o), writer, data, 0); + status = luaU_dump(L, getproto(o), writer, data, strip); else status = 1; lua_unlock(L); @@ -1047,19 +1066,21 @@ LUA_API int lua_gc (lua_State *L, int what, int data) { break; } case LUA_GCSTEP: { - if (g->gckind == KGC_GEN) { /* generational mode? */ - res = (g->GCestimate == 0); /* true if it will do major collection */ - luaC_forcestep(L); /* do a single step */ + l_mem debt = 1; /* =1 to signal that it did an actual step */ + lu_byte oldrunning = g->gcrunning; + g->gcrunning = 1; /* allow GC to run */ + if (data == 0) { + luaE_setdebt(g, -GCSTEPSIZE); /* to do a "small" step */ + luaC_step(L); } - else { - lu_mem debt = cast(lu_mem, data) * 1024 - GCSTEPSIZE; - if (g->gcrunning) - debt += g->GCdebt; /* include current debt */ - luaE_setdebt(g, debt); - luaC_forcestep(L); - if (g->gcstate == GCSpause) /* end of cycle? */ - res = 1; /* signal it */ + else { /* add 'data' to total debt */ + debt = cast(l_mem, data) * 1024 + g->GCdebt; + luaE_setdebt(g, debt); + luaC_checkGC(L); } + g->gcrunning = oldrunning; /* restore previous state */ + if (debt > 0 && g->gcstate == GCSpause) /* end of cycle? */ + res = 1; /* signal it */ break; } case LUA_GCSETPAUSE: { @@ -1067,13 +1088,9 @@ LUA_API int lua_gc (lua_State *L, int what, int data) { g->gcpause = data; break; } - case LUA_GCSETMAJORINC: { - res = g->gcmajorinc; - g->gcmajorinc = data; - break; - } case LUA_GCSETSTEPMUL: { res = g->gcstepmul; + if (data < 40) data = 40; /* avoid ridiculous low values (and 0) */ g->gcstepmul = data; break; } @@ -1081,14 +1098,6 @@ LUA_API int lua_gc (lua_State *L, int what, int data) { res = g->gcrunning; break; } - case LUA_GCGEN: { /* change collector to generational mode */ - luaC_changemode(L, KGC_GEN); - break; - } - case LUA_GCINC: { /* change collector to incremental mode */ - luaC_changemode(L, KGC_NORMAL); - break; - } default: res = -1; /* invalid option */ } lua_unlock(L); @@ -1132,7 +1141,6 @@ LUA_API void lua_concat (lua_State *L, int n) { lua_lock(L); api_checknelems(L, n); if (n >= 2) { - luaC_checkGC(L); luaV_concat(L, n); } else if (n == 0) { /* push empty string */ @@ -1140,6 +1148,7 @@ LUA_API void lua_concat (lua_State *L, int n) { api_incr_top(L); } /* else n == 1; nothing to do */ + luaC_checkGC(L); lua_unlock(L); } @@ -1175,24 +1184,24 @@ LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) { LUA_API void *lua_newuserdata (lua_State *L, size_t size) { Udata *u; lua_lock(L); - luaC_checkGC(L); - u = luaS_newudata(L, size, NULL); + u = luaS_newudata(L, size); setuvalue(L, L->top, u); api_incr_top(L); + luaC_checkGC(L); lua_unlock(L); - return u + 1; + return getudatamem(u); } static const char *aux_upvalue (StkId fi, int n, TValue **val, - GCObject **owner) { + CClosure **owner, UpVal **uv) { switch (ttype(fi)) { case LUA_TCCL: { /* C closure */ CClosure *f = clCvalue(fi); if (!(1 <= n && n <= f->nupvalues)) return NULL; *val = &f->upvalue[n-1]; - if (owner) *owner = obj2gco(f); + if (owner) *owner = f; return ""; } case LUA_TLCL: { /* Lua closure */ @@ -1201,9 +1210,9 @@ static const char *aux_upvalue (StkId fi, int n, TValue **val, Proto *p = f->p; if (!(1 <= n && n <= p->sizeupvalues)) return NULL; *val = f->upvals[n-1]->v; - if (owner) *owner = obj2gco(f->upvals[n - 1]); + if (uv) *uv = f->upvals[n - 1]; name = p->upvalues[n-1].name; - return (name == NULL) ? "" : getstr(name); + return (name == NULL) ? "(*no name)" : getstr(name); } default: return NULL; /* not a closure */ } @@ -1214,7 +1223,7 @@ LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) { const char *name; TValue *val = NULL; /* to avoid warnings */ lua_lock(L); - name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL); + name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL, NULL); if (name) { setobj2s(L, L->top, val); api_incr_top(L); @@ -1227,29 +1236,30 @@ LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) { LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) { const char *name; TValue *val = NULL; /* to avoid warnings */ - GCObject *owner = NULL; /* to avoid warnings */ + CClosure *owner = NULL; + UpVal *uv = NULL; StkId fi; lua_lock(L); fi = index2addr(L, funcindex); api_checknelems(L, 1); - name = aux_upvalue(fi, n, &val, &owner); + name = aux_upvalue(fi, n, &val, &owner, &uv); if (name) { L->top--; setobj(L, val, L->top); - luaC_barrier(L, owner, L->top); + if (owner) { luaC_barrier(L, owner, L->top); } + else if (uv) { luaC_upvalbarrier(L, uv); } } lua_unlock(L); return name; } -static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) { +static UpVal **getupvalref (lua_State *L, int fidx, int n) { LClosure *f; StkId fi = index2addr(L, fidx); api_check(L, ttisLclosure(fi), "Lua function expected"); f = clLvalue(fi); api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index"); - if (pf) *pf = f; return &f->upvals[n - 1]; /* get its upvalue pointer */ } @@ -1258,7 +1268,7 @@ LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) { StkId fi = index2addr(L, fidx); switch (ttype(fi)) { case LUA_TLCL: { /* lua closure */ - return *getupvalref(L, fidx, n, NULL); + return *getupvalref(L, fidx, n); } case LUA_TCCL: { /* C closure */ CClosure *f = clCvalue(fi); @@ -1275,10 +1285,15 @@ LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) { LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1, int fidx2, int n2) { - LClosure *f1; - UpVal **up1 = getupvalref(L, fidx1, n1, &f1); - UpVal **up2 = getupvalref(L, fidx2, n2, NULL); + UpVal **up1 = getupvalref(L, fidx1, n1); + UpVal **up2 = getupvalref(L, fidx2, n2); + if (*up1 == *up2) + return; + luaC_upvdeccount(L, *up1); *up1 = *up2; - luaC_objbarrier(L, f1, *up2); + (*up1)->refcount++; + if (upisopen(*up1)) (*up1)->u.open.touched = 1; + luaC_upvalbarrier(L, *up1); } + diff --git a/depends/lua/src/lauxlib.c b/depends/lua/src/lauxlib.c index b00f8c7096..ac68bd32da 100644 --- a/depends/lua/src/lauxlib.c +++ b/depends/lua/src/lauxlib.c @@ -1,9 +1,14 @@ /* -** $Id: lauxlib.c,v 1.248.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lauxlib.c,v 1.289.1.1 2017/04/19 17:20:42 roberto Exp $ ** Auxiliary functions for building Lua libraries ** See Copyright Notice in lua.h */ +#define lauxlib_c +#define LUA_LIB + +#include "lprefix.h" + #include #include @@ -12,13 +17,11 @@ #include -/* This file uses only the official API of Lua. +/* +** This file uses only the official API of Lua. ** Any function declared here could be written as an application function. */ -#define lauxlib_c -#define LUA_LIB - #include "lua.h" #include "lauxlib.h" @@ -31,8 +34,8 @@ */ -#define LEVELS1 12 /* size of the first part of the stack */ -#define LEVELS2 10 /* size of the second part of the stack */ +#define LEVELS1 10 /* size of the first part of the stack */ +#define LEVELS2 11 /* size of the second part of the stack */ @@ -64,11 +67,19 @@ static int findfield (lua_State *L, int objidx, int level) { } +/* +** Search for a name for a function in all loaded modules +*/ static int pushglobalfuncname (lua_State *L, lua_Debug *ar) { int top = lua_gettop(L); lua_getinfo(L, "f", ar); /* push function */ - lua_pushglobaltable(L); + lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); if (findfield(L, top + 1, 2)) { + const char *name = lua_tostring(L, -1); + if (strncmp(name, "_G.", 3) == 0) { /* name start with '_G.'? */ + lua_pushstring(L, name + 3); /* push name without prefix */ + lua_remove(L, -2); /* remove original name */ + } lua_copy(L, -1, top + 1); /* move name to proper place */ lua_pop(L, 2); /* remove pushed values */ return 1; @@ -81,24 +92,22 @@ static int pushglobalfuncname (lua_State *L, lua_Debug *ar) { static void pushfuncname (lua_State *L, lua_Debug *ar) { - if (*ar->namewhat != '\0') /* is there a name? */ - lua_pushfstring(L, "function " LUA_QS, ar->name); + if (pushglobalfuncname(L, ar)) { /* try first a global name */ + lua_pushfstring(L, "function '%s'", lua_tostring(L, -1)); + lua_remove(L, -2); /* remove name */ + } + else if (*ar->namewhat != '\0') /* is there a name from code? */ + lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name); /* use it */ else if (*ar->what == 'm') /* main? */ lua_pushliteral(L, "main chunk"); - else if (*ar->what == 'C') { - if (pushglobalfuncname(L, ar)) { - lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1)); - lua_remove(L, -2); /* remove name */ - } - else - lua_pushliteral(L, "?"); - } - else + else if (*ar->what != 'C') /* for Lua functions, use */ lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined); + else /* nothing left... */ + lua_pushliteral(L, "?"); } -static int countlevels (lua_State *L) { +static int lastlevel (lua_State *L) { lua_Debug ar; int li = 1, le = 1; /* find an upper bound */ @@ -117,14 +126,16 @@ LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1, const char *msg, int level) { lua_Debug ar; int top = lua_gettop(L); - int numlevels = countlevels(L1); - int mark = (numlevels > LEVELS1 + LEVELS2) ? LEVELS1 : 0; - if (msg) lua_pushfstring(L, "%s\n", msg); + int last = lastlevel(L1); + int n1 = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; + if (msg) + lua_pushfstring(L, "%s\n", msg); + luaL_checkstack(L, 10, NULL); lua_pushliteral(L, "stack traceback:"); while (lua_getstack(L1, level++, &ar)) { - if (level == mark) { /* too many levels? */ + if (n1-- == 0) { /* too many levels? */ lua_pushliteral(L, "\n\t..."); /* add a '...' */ - level = numlevels - LEVELS2; /* and skip to last ones */ + level = last - LEVELS2 + 1; /* and skip to last ones */ } else { lua_getinfo(L1, "Slnt", &ar); @@ -150,36 +161,47 @@ LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1, ** ======================================================= */ -LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) { +LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) { lua_Debug ar; if (!lua_getstack(L, 0, &ar)) /* no stack frame? */ - return luaL_error(L, "bad argument #%d (%s)", narg, extramsg); + return luaL_error(L, "bad argument #%d (%s)", arg, extramsg); lua_getinfo(L, "n", &ar); if (strcmp(ar.namewhat, "method") == 0) { - narg--; /* do not count `self' */ - if (narg == 0) /* error is in the self argument itself? */ - return luaL_error(L, "calling " LUA_QS " on bad self (%s)", + arg--; /* do not count 'self' */ + if (arg == 0) /* error is in the self argument itself? */ + return luaL_error(L, "calling '%s' on bad self (%s)", ar.name, extramsg); } if (ar.name == NULL) ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?"; - return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)", - narg, ar.name, extramsg); + return luaL_error(L, "bad argument #%d to '%s' (%s)", + arg, ar.name, extramsg); } -static int typeerror (lua_State *L, int narg, const char *tname) { - const char *msg = lua_pushfstring(L, "%s expected, got %s", - tname, luaL_typename(L, narg)); - return luaL_argerror(L, narg, msg); +static int typeerror (lua_State *L, int arg, const char *tname) { + const char *msg; + const char *typearg; /* name for the type of the actual argument */ + if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING) + typearg = lua_tostring(L, -1); /* use the given type name */ + else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA) + typearg = "light userdata"; /* special name for messages */ + else + typearg = luaL_typename(L, arg); /* standard name */ + msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg); + return luaL_argerror(L, arg, msg); } -static void tag_error (lua_State *L, int narg, int tag) { - typeerror(L, narg, lua_typename(L, tag)); +static void tag_error (lua_State *L, int arg, int tag) { + typeerror(L, arg, lua_typename(L, tag)); } +/* +** The use of 'lua_pushfstring' ensures this function does not +** need reserved stack space when called. +*/ LUALIB_API void luaL_where (lua_State *L, int level) { lua_Debug ar; if (lua_getstack(L, level, &ar)) { /* check function at level */ @@ -189,10 +211,15 @@ LUALIB_API void luaL_where (lua_State *L, int level) { return; } } - lua_pushliteral(L, ""); /* else, no information available... */ + lua_pushfstring(L, ""); /* else, no information available... */ } +/* +** Again, the use of 'lua_pushvfstring' ensures this function does +** not need reserved stack space when called. (At worst, it generates +** an error with "stack overflow" instead of the given message.) +*/ LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) { va_list argp; va_start(argp, fmt); @@ -222,7 +249,7 @@ LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) { } -#if !defined(inspectstat) /* { */ +#if !defined(l_inspectstat) /* { */ #if defined(LUA_USE_POSIX) @@ -231,13 +258,13 @@ LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) { /* ** use appropriate macros to interpret 'pclose' return status */ -#define inspectstat(stat,what) \ +#define l_inspectstat(stat,what) \ if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \ else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; } #else -#define inspectstat(stat,what) /* no op */ +#define l_inspectstat(stat,what) /* no op */ #endif @@ -249,7 +276,7 @@ LUALIB_API int luaL_execresult (lua_State *L, int stat) { if (stat == -1) /* error? */ return luaL_fileresult(L, 0, NULL); else { - inspectstat(stat, what); /* interpret result */ + l_inspectstat(stat, what); /* interpret result */ if (*what == 'e' && stat == 0) /* successful termination? */ lua_pushboolean(L, 1); else @@ -270,11 +297,12 @@ LUALIB_API int luaL_execresult (lua_State *L, int stat) { */ LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { - luaL_getmetatable(L, tname); /* try to get metatable */ - if (!lua_isnil(L, -1)) /* name already in use? */ + if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ return 0; /* leave previous value on top, but return 0 */ lua_pop(L, 1); - lua_newtable(L); /* create metatable */ + lua_createtable(L, 0, 2); /* create metatable */ + lua_pushstring(L, tname); + lua_setfield(L, -2, "__name"); /* metatable.__name = tname */ lua_pushvalue(L, -1); lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */ return 1; @@ -317,23 +345,28 @@ LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) { ** ======================================================= */ -LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def, +LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def, const char *const lst[]) { - const char *name = (def) ? luaL_optstring(L, narg, def) : - luaL_checkstring(L, narg); + const char *name = (def) ? luaL_optstring(L, arg, def) : + luaL_checkstring(L, arg); int i; for (i=0; lst[i]; i++) if (strcmp(lst[i], name) == 0) return i; - return luaL_argerror(L, narg, - lua_pushfstring(L, "invalid option " LUA_QS, name)); + return luaL_argerror(L, arg, + lua_pushfstring(L, "invalid option '%s'", name)); } +/* +** Ensures the stack has at least 'space' extra slots, raising an error +** if it cannot fulfill the request. (The error handling needs a few +** extra slots to format the error message. In case of an error without +** this extra space, Lua will generate the same 'stack overflow' error, +** but without 'msg'.) +*/ LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { - /* keep some extra space to run error routines, if needed */ - const int extra = LUA_MINSTACK; - if (!lua_checkstack(L, space + extra)) { + if (!lua_checkstack(L, space)) { if (msg) luaL_error(L, "stack overflow (%s)", msg); else @@ -342,77 +375,71 @@ LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { } -LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) { - if (lua_type(L, narg) != t) - tag_error(L, narg, t); +LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) { + if (lua_type(L, arg) != t) + tag_error(L, arg, t); } -LUALIB_API void luaL_checkany (lua_State *L, int narg) { - if (lua_type(L, narg) == LUA_TNONE) - luaL_argerror(L, narg, "value expected"); +LUALIB_API void luaL_checkany (lua_State *L, int arg) { + if (lua_type(L, arg) == LUA_TNONE) + luaL_argerror(L, arg, "value expected"); } -LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) { - const char *s = lua_tolstring(L, narg, len); - if (!s) tag_error(L, narg, LUA_TSTRING); +LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) { + const char *s = lua_tolstring(L, arg, len); + if (!s) tag_error(L, arg, LUA_TSTRING); return s; } -LUALIB_API const char *luaL_optlstring (lua_State *L, int narg, +LUALIB_API const char *luaL_optlstring (lua_State *L, int arg, const char *def, size_t *len) { - if (lua_isnoneornil(L, narg)) { + if (lua_isnoneornil(L, arg)) { if (len) *len = (def ? strlen(def) : 0); return def; } - else return luaL_checklstring(L, narg, len); + else return luaL_checklstring(L, arg, len); } -LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) { +LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) { int isnum; - lua_Number d = lua_tonumberx(L, narg, &isnum); + lua_Number d = lua_tonumberx(L, arg, &isnum); if (!isnum) - tag_error(L, narg, LUA_TNUMBER); + tag_error(L, arg, LUA_TNUMBER); return d; } -LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) { - return luaL_opt(L, luaL_checknumber, narg, def); +LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) { + return luaL_opt(L, luaL_checknumber, arg, def); } -LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) { - int isnum; - lua_Integer d = lua_tointegerx(L, narg, &isnum); - if (!isnum) - tag_error(L, narg, LUA_TNUMBER); - return d; +static void interror (lua_State *L, int arg) { + if (lua_isnumber(L, arg)) + luaL_argerror(L, arg, "number has no integer representation"); + else + tag_error(L, arg, LUA_TNUMBER); } -LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int narg) { +LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) { int isnum; - lua_Unsigned d = lua_tounsignedx(L, narg, &isnum); - if (!isnum) - tag_error(L, narg, LUA_TNUMBER); + lua_Integer d = lua_tointegerx(L, arg, &isnum); + if (!isnum) { + interror(L, arg); + } return d; } -LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg, +LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg, lua_Integer def) { - return luaL_opt(L, luaL_checkinteger, narg, def); -} - - -LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int narg, - lua_Unsigned def) { - return luaL_opt(L, luaL_checkunsigned, narg, def); + return luaL_opt(L, luaL_checkinteger, arg, def); } /* }====================================================== */ @@ -424,6 +451,47 @@ LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int narg, ** ======================================================= */ +/* userdata to box arbitrary data */ +typedef struct UBox { + void *box; + size_t bsize; +} UBox; + + +static void *resizebox (lua_State *L, int idx, size_t newsize) { + void *ud; + lua_Alloc allocf = lua_getallocf(L, &ud); + UBox *box = (UBox *)lua_touserdata(L, idx); + void *temp = allocf(ud, box->box, box->bsize, newsize); + if (temp == NULL && newsize > 0) { /* allocation error? */ + resizebox(L, idx, 0); /* free buffer */ + luaL_error(L, "not enough memory for buffer allocation"); + } + box->box = temp; + box->bsize = newsize; + return temp; +} + + +static int boxgc (lua_State *L) { + resizebox(L, 1, 0); + return 0; +} + + +static void *newbox (lua_State *L, size_t newsize) { + UBox *box = (UBox *)lua_newuserdata(L, sizeof(UBox)); + box->box = NULL; + box->bsize = 0; + if (luaL_newmetatable(L, "LUABOX")) { /* creating metatable? */ + lua_pushcfunction(L, boxgc); + lua_setfield(L, -2, "__gc"); /* metatable.__gc = boxgc */ + } + lua_setmetatable(L, -2); + return resizebox(L, -1, newsize); +} + + /* ** check whether buffer is using a userdata on the stack as a temporary ** buffer @@ -444,11 +512,12 @@ LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) { if (newsize < B->n || newsize - B->n < sz) luaL_error(L, "buffer too large"); /* create larger buffer */ - newbuff = (char *)lua_newuserdata(L, newsize * sizeof(char)); - /* move content to new buffer */ - memcpy(newbuff, B->b, B->n * sizeof(char)); if (buffonstack(B)) - lua_remove(L, -2); /* remove old buffer */ + newbuff = (char *)resizebox(L, -1, newsize); + else { /* no buffer yet */ + newbuff = (char *)newbox(L, newsize); + memcpy(newbuff, B->b, B->n * sizeof(char)); /* copy original content */ + } B->b = newbuff; B->size = newsize; } @@ -457,9 +526,11 @@ LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) { LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { - char *b = luaL_prepbuffsize(B, l); - memcpy(b, s, l * sizeof(char)); - luaL_addsize(B, l); + if (l > 0) { /* avoid 'memcpy' when 's' can be NULL */ + char *b = luaL_prepbuffsize(B, l); + memcpy(b, s, l * sizeof(char)); + luaL_addsize(B, l); + } } @@ -471,8 +542,10 @@ LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { LUALIB_API void luaL_pushresult (luaL_Buffer *B) { lua_State *L = B->L; lua_pushlstring(L, B->b, B->n); - if (buffonstack(B)) - lua_remove(L, -2); /* remove old buffer */ + if (buffonstack(B)) { + resizebox(L, -2, 0); /* delete old buffer */ + lua_remove(L, -2); /* remove its header from the stack */ + } } @@ -523,7 +596,7 @@ LUALIB_API int luaL_ref (lua_State *L, int t) { int ref; if (lua_isnil(L, -1)) { lua_pop(L, 1); /* remove from stack */ - return LUA_REFNIL; /* `nil' has a unique fixed reference */ + return LUA_REFNIL; /* 'nil' has a unique fixed reference */ } t = lua_absindex(L, t); lua_rawgeti(L, t, freelist); /* get first free element */ @@ -562,7 +635,7 @@ LUALIB_API void luaL_unref (lua_State *L, int t, int ref) { typedef struct LoadF { int n; /* number of pre-read characters */ FILE *f; /* file being read */ - char buff[LUAL_BUFFERSIZE]; /* area for reading file */ + char buff[BUFSIZ]; /* area for reading file */ } LoadF; @@ -594,7 +667,7 @@ static int errfile (lua_State *L, const char *what, int fnameindex) { static int skipBOM (LoadF *lf) { - const char *p = "\xEF\xBB\xBF"; /* Utf8 BOM mark */ + const char *p = "\xEF\xBB\xBF"; /* UTF-8 BOM mark */ int c; lf->n = 0; do { @@ -619,7 +692,7 @@ static int skipcomment (LoadF *lf, int *cp) { if (c == '#') { /* first line is a comment (Unix exec. file)? */ do { /* skip first line */ c = getc(lf->f); - } while (c != EOF && c != '\n') ; + } while (c != EOF && c != '\n'); *cp = getc(lf->f); /* skip end-of-line, if present */ return 1; /* there was a comment */ } @@ -655,7 +728,7 @@ LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename, readstatus = ferror(lf.f); if (filename) fclose(lf.f); /* close file (even in case of errors) */ if (readstatus) { - lua_settop(L, fnameindex); /* ignore results from `lua_load' */ + lua_settop(L, fnameindex); /* ignore results from 'lua_load' */ return errfile(L, "read", fnameindex); } lua_remove(L, fnameindex); @@ -698,23 +771,23 @@ LUALIB_API int luaL_loadstring (lua_State *L, const char *s) { LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) { if (!lua_getmetatable(L, obj)) /* no metatable? */ - return 0; - lua_pushstring(L, event); - lua_rawget(L, -2); - if (lua_isnil(L, -1)) { - lua_pop(L, 2); /* remove metatable and metafield */ - return 0; - } + return LUA_TNIL; else { - lua_remove(L, -2); /* remove only metatable */ - return 1; + int tt; + lua_pushstring(L, event); + tt = lua_rawget(L, -2); + if (tt == LUA_TNIL) /* is metafield nil? */ + lua_pop(L, 2); /* remove metatable and metafield */ + else + lua_remove(L, -2); /* remove only metatable */ + return tt; /* return metafield type */ } } LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) { obj = lua_absindex(L, obj); - if (!luaL_getmetafield(L, obj, event)) /* no metafield? */ + if (luaL_getmetafield(L, obj, event) == LUA_TNIL) /* no metafield? */ return 0; lua_pushvalue(L, obj); lua_call(L, 1, 1); @@ -722,22 +795,32 @@ LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) { } -LUALIB_API int luaL_len (lua_State *L, int idx) { - int l; +LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) { + lua_Integer l; int isnum; lua_len(L, idx); - l = (int)lua_tointegerx(L, -1, &isnum); + l = lua_tointegerx(L, -1, &isnum); if (!isnum) - luaL_error(L, "object length is not a number"); + luaL_error(L, "object length is not an integer"); lua_pop(L, 1); /* remove object */ return l; } LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) { - if (!luaL_callmeta(L, idx, "__tostring")) { /* no metafield? */ + if (luaL_callmeta(L, idx, "__tostring")) { /* metafield? */ + if (!lua_isstring(L, -1)) + luaL_error(L, "'__tostring' must return a string"); + } + else { switch (lua_type(L, idx)) { - case LUA_TNUMBER: + case LUA_TNUMBER: { + if (lua_isinteger(L, idx)) + lua_pushfstring(L, "%I", (LUAI_UACINT)lua_tointeger(L, idx)); + else + lua_pushfstring(L, "%f", (LUAI_UACNUMBER)lua_tonumber(L, idx)); + break; + } case LUA_TSTRING: lua_pushvalue(L, idx); break; @@ -747,10 +830,15 @@ LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) { case LUA_TNIL: lua_pushliteral(L, "nil"); break; - default: - lua_pushfstring(L, "%s: %p", luaL_typename(L, idx), - lua_topointer(L, idx)); + default: { + int tt = luaL_getmetafield(L, idx, "__name"); /* try name */ + const char *kind = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : + luaL_typename(L, idx); + lua_pushfstring(L, "%s: %p", kind, lua_topointer(L, idx)); + if (tt != LUA_TNIL) + lua_remove(L, -2); /* remove '__name' */ break; + } } } return lua_tolstring(L, -1, len); @@ -772,8 +860,7 @@ static const char *luaL_findtable (lua_State *L, int idx, e = strchr(fname, '.'); if (e == NULL) e = fname + strlen(fname); lua_pushlstring(L, fname, e - fname); - lua_rawget(L, -2); - if (lua_isnil(L, -1)) { /* no such field? */ + if (lua_rawget(L, -2) == LUA_TNIL) { /* no such field? */ lua_pop(L, 1); /* remove this nil */ lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */ lua_pushlstring(L, fname, e - fname); @@ -803,24 +890,23 @@ static int libsize (const luaL_Reg *l) { /* ** Find or create a module table with a given name. The function -** first looks at the _LOADED table and, if that fails, try a +** first looks at the LOADED table and, if that fails, try a ** global variable with that name. In any case, leaves on the stack ** the module table. */ LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname, int sizehint) { - luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1); /* get _LOADED table */ - lua_getfield(L, -1, modname); /* get _LOADED[modname] */ - if (!lua_istable(L, -1)) { /* not found? */ + luaL_findtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE, 1); + if (lua_getfield(L, -1, modname) != LUA_TTABLE) { /* no LOADED[modname]? */ lua_pop(L, 1); /* remove previous result */ /* try global variable (and create one if it does not exist) */ lua_pushglobaltable(L); if (luaL_findtable(L, 0, modname, sizehint) != NULL) - luaL_error(L, "name conflict for module " LUA_QS, modname); + luaL_error(L, "name conflict for module '%s'", modname); lua_pushvalue(L, -1); - lua_setfield(L, -3, modname); /* _LOADED[modname] = new table */ + lua_setfield(L, -3, modname); /* LOADED[modname] = new table */ } - lua_remove(L, -2); /* remove _LOADED table */ + lua_remove(L, -2); /* remove LOADED table */ } @@ -846,7 +932,6 @@ LUALIB_API void luaL_openlib (lua_State *L, const char *libname, ** Returns with only the table at the stack. */ LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { - luaL_checkversion(L); luaL_checkstack(L, nup, "too many upvalues"); for (; l->name != NULL; l++) { /* fill the table with given functions */ int i; @@ -864,8 +949,8 @@ LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { ** into the stack */ LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) { - lua_getfield(L, idx, fname); - if (lua_istable(L, -1)) return 1; /* table already there */ + if (lua_getfield(L, idx, fname) == LUA_TTABLE) + return 1; /* table already there */ else { lua_pop(L, 1); /* remove previous result */ idx = lua_absindex(L, idx); @@ -878,22 +963,26 @@ LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) { /* -** stripped-down 'require'. Calls 'openf' to open a module, -** registers the result in 'package.loaded' table and, if 'glb' -** is true, also registers the result in the global table. +** Stripped-down 'require': After checking "loaded" table, calls 'openf' +** to open a module, registers the result in 'package.loaded' table and, +** if 'glb' is true, also registers the result in the global table. ** Leaves resulting module on the top. */ LUALIB_API void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int glb) { - lua_pushcfunction(L, openf); - lua_pushstring(L, modname); /* argument to open function */ - lua_call(L, 1, 1); /* open module */ - luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED"); - lua_pushvalue(L, -2); /* make copy of module (call result) */ - lua_setfield(L, -2, modname); /* _LOADED[modname] = module */ - lua_pop(L, 1); /* remove _LOADED table */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); + lua_getfield(L, -1, modname); /* LOADED[modname] */ + if (!lua_toboolean(L, -1)) { /* package not already loaded? */ + lua_pop(L, 1); /* remove field */ + lua_pushcfunction(L, openf); + lua_pushstring(L, modname); /* argument to open function */ + lua_call(L, 1, 1); /* call 'openf' to open module */ + lua_pushvalue(L, -1); /* make copy of module (call result) */ + lua_setfield(L, -3, modname); /* LOADED[modname] = module */ + } + lua_remove(L, -2); /* remove LOADED table */ if (glb) { - lua_pushvalue(L, -1); /* copy of 'mod' */ + lua_pushvalue(L, -1); /* copy of module */ lua_setglobal(L, modname); /* _G[modname] = module */ } } @@ -908,7 +997,7 @@ LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p, while ((wild = strstr(s, p)) != NULL) { luaL_addlstring(&b, s, wild - s); /* push prefix */ luaL_addstring(&b, r); /* push replacement in place of pattern */ - s = wild + l; /* continue after `p' */ + s = wild + l; /* continue after 'p' */ } luaL_addstring(&b, s); /* push last suffix */ luaL_pushresult(&b); @@ -922,14 +1011,19 @@ static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { free(ptr); return NULL; } - else - return realloc(ptr, nsize); + else { /* cannot fail when shrinking a block */ + void *newptr = realloc(ptr, nsize); + if (newptr == NULL && ptr != NULL && nsize <= osize) + return ptr; /* keep the original block */ + else /* no fail or not shrinking */ + return newptr; /* use the new block */ + } } static int panic (lua_State *L) { - luai_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n", - lua_tostring(L, -1)); + lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n", + lua_tostring(L, -1)); return 0; /* return to Lua to abort */ } @@ -941,19 +1035,14 @@ LUALIB_API lua_State *luaL_newstate (void) { } -LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver) { +LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) { const lua_Number *v = lua_version(L); + if (sz != LUAL_NUMSIZES) /* check numeric types */ + luaL_error(L, "core and library have incompatible numeric types"); if (v != lua_version(NULL)) luaL_error(L, "multiple Lua VMs detected"); else if (*v != ver) luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f", - ver, *v); - /* check conversions number -> integer types */ - lua_pushnumber(L, -(lua_Number)0x1234); - if (lua_tointeger(L, -1) != -0x1234 || - lua_tounsigned(L, -1) != (lua_Unsigned)-0x1234) - luaL_error(L, "bad conversion number->int;" - " must recompile Lua with proper settings"); - lua_pop(L, 1); + (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)*v); } diff --git a/depends/lua/src/lbaselib.c b/depends/lua/src/lbaselib.c index 5255b3cd9b..6460e4f8d4 100644 --- a/depends/lua/src/lbaselib.c +++ b/depends/lua/src/lbaselib.c @@ -1,9 +1,13 @@ /* -** $Id: lbaselib.c,v 1.276.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lbaselib.c,v 1.314.1.1 2017/04/19 17:39:34 roberto Exp $ ** Basic library ** See Copyright Notice in lua.h */ +#define lbaselib_c +#define LUA_LIB + +#include "lprefix.h" #include @@ -11,9 +15,6 @@ #include #include -#define lbaselib_c -#define LUA_LIB - #include "lua.h" #include "lauxlib.h" @@ -32,65 +33,77 @@ static int luaB_print (lua_State *L) { lua_call(L, 1, 1); s = lua_tolstring(L, -1, &l); /* get result */ if (s == NULL) - return luaL_error(L, - LUA_QL("tostring") " must return a string to " LUA_QL("print")); - if (i>1) luai_writestring("\t", 1); - luai_writestring(s, l); + return luaL_error(L, "'tostring' must return a string to 'print'"); + if (i>1) lua_writestring("\t", 1); + lua_writestring(s, l); lua_pop(L, 1); /* pop result */ } - luai_writeline(); + lua_writeline(); return 0; } #define SPACECHARS " \f\n\r\t\v" +static const char *b_str2int (const char *s, int base, lua_Integer *pn) { + lua_Unsigned n = 0; + int neg = 0; + s += strspn(s, SPACECHARS); /* skip initial spaces */ + if (*s == '-') { s++; neg = 1; } /* handle signal */ + else if (*s == '+') s++; + if (!isalnum((unsigned char)*s)) /* no digit? */ + return NULL; + do { + int digit = (isdigit((unsigned char)*s)) ? *s - '0' + : (toupper((unsigned char)*s) - 'A') + 10; + if (digit >= base) return NULL; /* invalid numeral */ + n = n * base + digit; + s++; + } while (isalnum((unsigned char)*s)); + s += strspn(s, SPACECHARS); /* skip trailing spaces */ + *pn = (lua_Integer)((neg) ? (0u - n) : n); + return s; +} + + static int luaB_tonumber (lua_State *L) { - if (lua_isnoneornil(L, 2)) { /* standard conversion */ - int isnum; - lua_Number n = lua_tonumberx(L, 1, &isnum); - if (isnum) { - lua_pushnumber(L, n); - return 1; - } /* else not a number; must be something */ + if (lua_isnoneornil(L, 2)) { /* standard conversion? */ luaL_checkany(L, 1); + if (lua_type(L, 1) == LUA_TNUMBER) { /* already a number? */ + lua_settop(L, 1); /* yes; return it */ + return 1; + } + else { + size_t l; + const char *s = lua_tolstring(L, 1, &l); + if (s != NULL && lua_stringtonumber(L, s) == l + 1) + return 1; /* successful conversion to number */ + /* else not a number */ + } } else { size_t l; - const char *s = luaL_checklstring(L, 1, &l); - const char *e = s + l; /* end point for 's' */ - int base = luaL_checkint(L, 2); - int neg = 0; + const char *s; + lua_Integer n = 0; /* to avoid warnings */ + lua_Integer base = luaL_checkinteger(L, 2); + luaL_checktype(L, 1, LUA_TSTRING); /* no numbers as strings */ + s = lua_tolstring(L, 1, &l); luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range"); - s += strspn(s, SPACECHARS); /* skip initial spaces */ - if (*s == '-') { s++; neg = 1; } /* handle signal */ - else if (*s == '+') s++; - if (isalnum((unsigned char)*s)) { - lua_Number n = 0; - do { - int digit = (isdigit((unsigned char)*s)) ? *s - '0' - : toupper((unsigned char)*s) - 'A' + 10; - if (digit >= base) break; /* invalid numeral; force a fail */ - n = n * (lua_Number)base + (lua_Number)digit; - s++; - } while (isalnum((unsigned char)*s)); - s += strspn(s, SPACECHARS); /* skip trailing spaces */ - if (s == e) { /* no invalid trailing characters? */ - lua_pushnumber(L, (neg) ? -n : n); - return 1; - } /* else not a number */ + if (b_str2int(s, (int)base, &n) == s + l) { + lua_pushinteger(L, n); + return 1; } /* else not a number */ - } + } /* else not a number */ lua_pushnil(L); /* not a number */ return 1; } static int luaB_error (lua_State *L) { - int level = luaL_optint(L, 2, 1); + int level = (int)luaL_optinteger(L, 2, 1); lua_settop(L, 1); - if (lua_isstring(L, 1) && level > 0) { /* add extra information? */ - luaL_where(L, level); + if (lua_type(L, 1) == LUA_TSTRING && level > 0) { + luaL_where(L, level); /* add extra information */ lua_pushvalue(L, 1); lua_concat(L, 2); } @@ -114,7 +127,7 @@ static int luaB_setmetatable (lua_State *L) { luaL_checktype(L, 1, LUA_TTABLE); luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table expected"); - if (luaL_getmetafield(L, 1, "__metatable")) + if (luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL) return luaL_error(L, "cannot change a protected metatable"); lua_settop(L, 2); lua_setmetatable(L, 1); @@ -160,19 +173,18 @@ static int luaB_rawset (lua_State *L) { static int luaB_collectgarbage (lua_State *L) { static const char *const opts[] = {"stop", "restart", "collect", "count", "step", "setpause", "setstepmul", - "setmajorinc", "isrunning", "generational", "incremental", NULL}; + "isrunning", NULL}; static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT, LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL, - LUA_GCSETMAJORINC, LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC}; + LUA_GCISRUNNING}; int o = optsnum[luaL_checkoption(L, 1, "collect", opts)]; - int ex = luaL_optint(L, 2, 0); + int ex = (int)luaL_optinteger(L, 2, 0); int res = lua_gc(L, o, ex); switch (o) { case LUA_GCCOUNT: { int b = lua_gc(L, LUA_GCCOUNTB, 0); - lua_pushnumber(L, res + ((lua_Number)b/1024)); - lua_pushinteger(L, b); - return 2; + lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024)); + return 1; } case LUA_GCSTEP: case LUA_GCISRUNNING: { lua_pushboolean(L, res); @@ -187,16 +199,17 @@ static int luaB_collectgarbage (lua_State *L) { static int luaB_type (lua_State *L) { - luaL_checkany(L, 1); - lua_pushstring(L, luaL_typename(L, 1)); + int t = lua_type(L, 1); + luaL_argcheck(L, t != LUA_TNONE, 1, "value expected"); + lua_pushstring(L, lua_typename(L, t)); return 1; } static int pairsmeta (lua_State *L, const char *method, int iszero, lua_CFunction iter) { - if (!luaL_getmetafield(L, 1, method)) { /* no metamethod? */ - luaL_checktype(L, 1, LUA_TTABLE); /* argument must be a table */ + luaL_checkany(L, 1); + if (luaL_getmetafield(L, 1, method) == LUA_TNIL) { /* no metamethod? */ lua_pushcfunction(L, iter); /* will return generator, */ lua_pushvalue(L, 1); /* state, */ if (iszero) lua_pushinteger(L, 0); /* and initial value */ @@ -227,18 +240,30 @@ static int luaB_pairs (lua_State *L) { } +/* +** Traversal function for 'ipairs' +*/ static int ipairsaux (lua_State *L) { - int i = luaL_checkint(L, 2); - luaL_checktype(L, 1, LUA_TTABLE); - i++; /* next value */ + lua_Integer i = luaL_checkinteger(L, 2) + 1; lua_pushinteger(L, i); - lua_rawgeti(L, 1, i); - return (lua_isnil(L, -1)) ? 1 : 2; + return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2; } +/* +** 'ipairs' function. Returns 'ipairsaux', given "table", 0. +** (The given "table" may not be a table.) +*/ static int luaB_ipairs (lua_State *L) { +#if defined(LUA_COMPAT_IPAIRS) return pairsmeta(L, "__ipairs", 1, ipairsaux); +#else + luaL_checkany(L, 1); + lua_pushcfunction(L, ipairsaux); /* iteration function */ + lua_pushvalue(L, 1); /* state */ + lua_pushinteger(L, 0); /* initial value */ + return 3; +#endif } @@ -284,7 +309,7 @@ static int luaB_loadfile (lua_State *L) { /* -** Reader for generic `load' function: `lua_load' uses the +** Reader for generic 'load' function: 'lua_load' uses the ** stack for internal stuff, so the reader cannot change the ** stack top. Instead, it keeps its resulting string in a ** reserved slot inside the stack. @@ -328,7 +353,8 @@ static int luaB_load (lua_State *L) { /* }====================================================== */ -static int dofilecont (lua_State *L) { +static int dofilecont (lua_State *L, int d1, lua_KContext d2) { + (void)d1; (void)d2; /* only to match 'lua_Kfunction' prototype */ return lua_gettop(L) - 1; } @@ -339,14 +365,20 @@ static int luaB_dofile (lua_State *L) { if (luaL_loadfile(L, fname) != LUA_OK) return lua_error(L); lua_callk(L, 0, LUA_MULTRET, 0, dofilecont); - return dofilecont(L); + return dofilecont(L, 0, 0); } static int luaB_assert (lua_State *L) { - if (!lua_toboolean(L, 1)) - return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!")); - return lua_gettop(L); + if (lua_toboolean(L, 1)) /* condition is true? */ + return lua_gettop(L); /* return all arguments */ + else { /* error */ + luaL_checkany(L, 1); /* there must be a condition */ + lua_remove(L, 1); /* remove it */ + lua_pushliteral(L, "assertion failed!"); /* default message */ + lua_settop(L, 1); /* leave only message (default if no other one) */ + return luaB_error(L); /* call 'error' */ + } } @@ -357,53 +389,57 @@ static int luaB_select (lua_State *L) { return 1; } else { - int i = luaL_checkint(L, 1); + lua_Integer i = luaL_checkinteger(L, 1); if (i < 0) i = n + i; else if (i > n) i = n; luaL_argcheck(L, 1 <= i, 1, "index out of range"); - return n - i; + return n - (int)i; } } -static int finishpcall (lua_State *L, int status) { - if (!lua_checkstack(L, 1)) { /* no space for extra boolean? */ - lua_settop(L, 0); /* create space for return values */ - lua_pushboolean(L, 0); - lua_pushstring(L, "stack overflow"); +/* +** Continuation function for 'pcall' and 'xpcall'. Both functions +** already pushed a 'true' before doing the call, so in case of success +** 'finishpcall' only has to return everything in the stack minus +** 'extra' values (where 'extra' is exactly the number of items to be +** ignored). +*/ +static int finishpcall (lua_State *L, int status, lua_KContext extra) { + if (status != LUA_OK && status != LUA_YIELD) { /* error? */ + lua_pushboolean(L, 0); /* first result (false) */ + lua_pushvalue(L, -2); /* error message */ return 2; /* return false, msg */ } - lua_pushboolean(L, status); /* first result (status) */ - lua_replace(L, 1); /* put first result in first slot */ - return lua_gettop(L); -} - - -static int pcallcont (lua_State *L) { - int status = lua_getctx(L, NULL); - return finishpcall(L, (status == LUA_YIELD)); + else + return lua_gettop(L) - (int)extra; /* return all results */ } static int luaB_pcall (lua_State *L) { int status; luaL_checkany(L, 1); - lua_pushnil(L); - lua_insert(L, 1); /* create space for status result */ - status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, pcallcont); - return finishpcall(L, (status == LUA_OK)); + lua_pushboolean(L, 1); /* first result if no errors */ + lua_insert(L, 1); /* put it in place */ + status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall); + return finishpcall(L, status, 0); } +/* +** Do a protected call with error handling. After 'lua_rotate', the +** stack will have ; so, the function passes +** 2 to 'finishpcall' to skip the 2 first values when returning results. +*/ static int luaB_xpcall (lua_State *L) { int status; int n = lua_gettop(L); - luaL_argcheck(L, n >= 2, 2, "value expected"); - lua_pushvalue(L, 1); /* exchange function... */ - lua_copy(L, 2, 1); /* ...and error handler */ - lua_replace(L, 2); - status = lua_pcallk(L, n - 2, LUA_MULTRET, 1, 0, pcallcont); - return finishpcall(L, (status == LUA_OK)); + luaL_checktype(L, 2, LUA_TFUNCTION); /* check error function */ + lua_pushboolean(L, 1); /* first result */ + lua_pushvalue(L, 1); /* function */ + lua_rotate(L, 3, 2); /* move them below function's arguments */ + status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall); + return finishpcall(L, status, 2); } @@ -440,19 +476,23 @@ static const luaL_Reg base_funcs[] = { {"tostring", luaB_tostring}, {"type", luaB_type}, {"xpcall", luaB_xpcall}, + /* placeholders */ + {"_G", NULL}, + {"_VERSION", NULL}, {NULL, NULL} }; LUAMOD_API int luaopen_base (lua_State *L) { - /* set global _G */ - lua_pushglobaltable(L); - lua_pushglobaltable(L); - lua_setfield(L, -2, "_G"); /* open lib into global table */ + lua_pushglobaltable(L); luaL_setfuncs(L, base_funcs, 0); + /* set global _G */ + lua_pushvalue(L, -1); + lua_setfield(L, -2, "_G"); + /* set global _VERSION */ lua_pushliteral(L, LUA_VERSION); - lua_setfield(L, -2, "_VERSION"); /* set global _VERSION */ + lua_setfield(L, -2, "_VERSION"); return 1; } diff --git a/depends/lua/src/lbitlib.c b/depends/lua/src/lbitlib.c index 31c7b66f12..4786c0d483 100644 --- a/depends/lua/src/lbitlib.c +++ b/depends/lua/src/lbitlib.c @@ -1,5 +1,5 @@ /* -** $Id: lbitlib.c,v 1.18.1.2 2013/07/09 18:01:41 roberto Exp $ +** $Id: lbitlib.c,v 1.30.1.1 2017/04/19 17:20:42 roberto Exp $ ** Standard library for bitwise operations ** See Copyright Notice in lua.h */ @@ -7,20 +7,36 @@ #define lbitlib_c #define LUA_LIB +#include "lprefix.h" + + #include "lua.h" #include "lauxlib.h" #include "lualib.h" +#if defined(LUA_COMPAT_BITLIB) /* { */ + + +#define pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) +#define checkunsigned(L,i) ((lua_Unsigned)luaL_checkinteger(L,i)) + + /* number of bits to consider in a number */ #if !defined(LUA_NBITS) #define LUA_NBITS 32 #endif +/* +** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must +** be made in two parts to avoid problems when LUA_NBITS is equal to the +** number of bits in a lua_Unsigned.) +*/ #define ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1)) + /* macro to trim extra bits */ #define trim(x) ((x) & ALLONES) @@ -29,28 +45,25 @@ #define mask(n) (~((ALLONES << 1) << ((n) - 1))) -typedef lua_Unsigned b_uint; - - -static b_uint andaux (lua_State *L) { +static lua_Unsigned andaux (lua_State *L) { int i, n = lua_gettop(L); - b_uint r = ~(b_uint)0; + lua_Unsigned r = ~(lua_Unsigned)0; for (i = 1; i <= n; i++) - r &= luaL_checkunsigned(L, i); + r &= checkunsigned(L, i); return trim(r); } static int b_and (lua_State *L) { - b_uint r = andaux(L); - lua_pushunsigned(L, r); + lua_Unsigned r = andaux(L); + pushunsigned(L, r); return 1; } static int b_test (lua_State *L) { - b_uint r = andaux(L); + lua_Unsigned r = andaux(L); lua_pushboolean(L, r != 0); return 1; } @@ -58,32 +71,32 @@ static int b_test (lua_State *L) { static int b_or (lua_State *L) { int i, n = lua_gettop(L); - b_uint r = 0; + lua_Unsigned r = 0; for (i = 1; i <= n; i++) - r |= luaL_checkunsigned(L, i); - lua_pushunsigned(L, trim(r)); + r |= checkunsigned(L, i); + pushunsigned(L, trim(r)); return 1; } static int b_xor (lua_State *L) { int i, n = lua_gettop(L); - b_uint r = 0; + lua_Unsigned r = 0; for (i = 1; i <= n; i++) - r ^= luaL_checkunsigned(L, i); - lua_pushunsigned(L, trim(r)); + r ^= checkunsigned(L, i); + pushunsigned(L, trim(r)); return 1; } static int b_not (lua_State *L) { - b_uint r = ~luaL_checkunsigned(L, 1); - lua_pushunsigned(L, trim(r)); + lua_Unsigned r = ~checkunsigned(L, 1); + pushunsigned(L, trim(r)); return 1; } -static int b_shift (lua_State *L, b_uint r, int i) { +static int b_shift (lua_State *L, lua_Unsigned r, lua_Integer i) { if (i < 0) { /* shift right? */ i = -i; r = trim(r); @@ -95,54 +108,54 @@ static int b_shift (lua_State *L, b_uint r, int i) { else r <<= i; r = trim(r); } - lua_pushunsigned(L, r); + pushunsigned(L, r); return 1; } static int b_lshift (lua_State *L) { - return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkint(L, 2)); + return b_shift(L, checkunsigned(L, 1), luaL_checkinteger(L, 2)); } static int b_rshift (lua_State *L) { - return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkint(L, 2)); + return b_shift(L, checkunsigned(L, 1), -luaL_checkinteger(L, 2)); } static int b_arshift (lua_State *L) { - b_uint r = luaL_checkunsigned(L, 1); - int i = luaL_checkint(L, 2); - if (i < 0 || !(r & ((b_uint)1 << (LUA_NBITS - 1)))) + lua_Unsigned r = checkunsigned(L, 1); + lua_Integer i = luaL_checkinteger(L, 2); + if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1)))) return b_shift(L, r, -i); else { /* arithmetic shift for 'negative' number */ if (i >= LUA_NBITS) r = ALLONES; else - r = trim((r >> i) | ~(~(b_uint)0 >> i)); /* add signal bit */ - lua_pushunsigned(L, r); + r = trim((r >> i) | ~(trim(~(lua_Unsigned)0) >> i)); /* add signal bit */ + pushunsigned(L, r); return 1; } } -static int b_rot (lua_State *L, int i) { - b_uint r = luaL_checkunsigned(L, 1); - i &= (LUA_NBITS - 1); /* i = i % NBITS */ +static int b_rot (lua_State *L, lua_Integer d) { + lua_Unsigned r = checkunsigned(L, 1); + int i = d & (LUA_NBITS - 1); /* i = d % NBITS */ r = trim(r); if (i != 0) /* avoid undefined shift of LUA_NBITS when i == 0 */ r = (r << i) | (r >> (LUA_NBITS - i)); - lua_pushunsigned(L, trim(r)); + pushunsigned(L, trim(r)); return 1; } static int b_lrot (lua_State *L) { - return b_rot(L, luaL_checkint(L, 2)); + return b_rot(L, luaL_checkinteger(L, 2)); } static int b_rrot (lua_State *L) { - return b_rot(L, -luaL_checkint(L, 2)); + return b_rot(L, -luaL_checkinteger(L, 2)); } @@ -153,36 +166,35 @@ static int b_rrot (lua_State *L) { ** 'width' being used uninitialized.) */ static int fieldargs (lua_State *L, int farg, int *width) { - int f = luaL_checkint(L, farg); - int w = luaL_optint(L, farg + 1, 1); + lua_Integer f = luaL_checkinteger(L, farg); + lua_Integer w = luaL_optinteger(L, farg + 1, 1); luaL_argcheck(L, 0 <= f, farg, "field cannot be negative"); luaL_argcheck(L, 0 < w, farg + 1, "width must be positive"); if (f + w > LUA_NBITS) luaL_error(L, "trying to access non-existent bits"); - *width = w; - return f; + *width = (int)w; + return (int)f; } static int b_extract (lua_State *L) { int w; - b_uint r = luaL_checkunsigned(L, 1); + lua_Unsigned r = trim(checkunsigned(L, 1)); int f = fieldargs(L, 2, &w); r = (r >> f) & mask(w); - lua_pushunsigned(L, r); + pushunsigned(L, r); return 1; } static int b_replace (lua_State *L) { int w; - b_uint r = luaL_checkunsigned(L, 1); - b_uint v = luaL_checkunsigned(L, 2); + lua_Unsigned r = trim(checkunsigned(L, 1)); + lua_Unsigned v = trim(checkunsigned(L, 2)); int f = fieldargs(L, 3, &w); - int m = mask(w); - v &= m; /* erase bits outside given width */ - r = (r & ~(m << f)) | (v << f); - lua_pushunsigned(L, r); + lua_Unsigned m = mask(w); + r = (r & ~(m << f)) | ((v & m) << f); + pushunsigned(L, r); return 1; } @@ -210,3 +222,12 @@ LUAMOD_API int luaopen_bit32 (lua_State *L) { return 1; } + +#else /* }{ */ + + +LUAMOD_API int luaopen_bit32 (lua_State *L) { + return luaL_error(L, "library 'bit32' has been deprecated"); +} + +#endif /* } */ diff --git a/depends/lua/src/lcode.c b/depends/lua/src/lcode.c index 820b95c0e1..dc7271d614 100644 --- a/depends/lua/src/lcode.c +++ b/depends/lua/src/lcode.c @@ -1,15 +1,18 @@ /* -** $Id: lcode.c,v 2.62.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lcode.c,v 2.112.1.1 2017/04/19 17:20:42 roberto Exp $ ** Code generator for Lua ** See Copyright Notice in lua.h */ - -#include - #define lcode_c #define LUA_CORE +#include "lprefix.h" + + +#include +#include + #include "lua.h" #include "lcode.h" @@ -26,21 +29,45 @@ #include "lvm.h" +/* Maximum number of registers in a Lua function (must fit in 8 bits) */ +#define MAXREGS 255 + + #define hasjumps(e) ((e)->t != (e)->f) -static int isnumeral(expdesc *e) { - return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP); +/* +** If expression is a numeric constant, fills 'v' with its value +** and returns 1. Otherwise, returns 0. +*/ +static int tonumeral(const expdesc *e, TValue *v) { + if (hasjumps(e)) + return 0; /* not a numeral */ + switch (e->k) { + case VKINT: + if (v) setivalue(v, e->u.ival); + return 1; + case VKFLT: + if (v) setfltvalue(v, e->u.nval); + return 1; + default: return 0; + } } +/* +** Create a OP_LOADNIL instruction, but try to optimize: if the previous +** instruction is also OP_LOADNIL and ranges are compatible, adjust +** range of previous instruction instead of emitting a new one. (For +** instance, 'local a; local b' will generate a single opcode.) +*/ void luaK_nil (FuncState *fs, int from, int n) { Instruction *previous; int l = from + n - 1; /* last register to set nil */ if (fs->pc > fs->lasttarget) { /* no jumps to current position? */ previous = &fs->f->code[fs->pc-1]; - if (GET_OPCODE(*previous) == OP_LOADNIL) { - int pfrom = GETARG_A(*previous); + if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ + int pfrom = GETARG_A(*previous); /* get previous range */ int pl = pfrom + GETARG_B(*previous); if ((pfrom <= from && from <= pl + 1) || (from <= pfrom && pfrom <= l + 1)) { /* can connect both? */ @@ -56,39 +83,86 @@ void luaK_nil (FuncState *fs, int from, int n) { } +/* +** Gets the destination address of a jump instruction. Used to traverse +** a list of jumps. +*/ +static int getjump (FuncState *fs, int pc) { + int offset = GETARG_sBx(fs->f->code[pc]); + if (offset == NO_JUMP) /* point to itself represents end of list */ + return NO_JUMP; /* end of list */ + else + return (pc+1)+offset; /* turn offset into absolute position */ +} + + +/* +** Fix jump instruction at position 'pc' to jump to 'dest'. +** (Jump addresses are relative in Lua) +*/ +static void fixjump (FuncState *fs, int pc, int dest) { + Instruction *jmp = &fs->f->code[pc]; + int offset = dest - (pc + 1); + lua_assert(dest != NO_JUMP); + if (abs(offset) > MAXARG_sBx) + luaX_syntaxerror(fs->ls, "control structure too long"); + SETARG_sBx(*jmp, offset); +} + + +/* +** Concatenate jump-list 'l2' into jump-list 'l1' +*/ +void luaK_concat (FuncState *fs, int *l1, int l2) { + if (l2 == NO_JUMP) return; /* nothing to concatenate? */ + else if (*l1 == NO_JUMP) /* no original list? */ + *l1 = l2; /* 'l1' points to 'l2' */ + else { + int list = *l1; + int next; + while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */ + list = next; + fixjump(fs, list, l2); /* last element links to 'l2' */ + } +} + + +/* +** Create a jump instruction and return its position, so its destination +** can be fixed later (with 'fixjump'). If there are jumps to +** this position (kept in 'jpc'), link them all together so that +** 'patchlistaux' will fix all them directly to the final destination. +*/ int luaK_jump (FuncState *fs) { int jpc = fs->jpc; /* save list of jumps to here */ int j; - fs->jpc = NO_JUMP; + fs->jpc = NO_JUMP; /* no more jumps to here */ j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP); luaK_concat(fs, &j, jpc); /* keep them on hold */ return j; } +/* +** Code a 'return' instruction +*/ void luaK_ret (FuncState *fs, int first, int nret) { luaK_codeABC(fs, OP_RETURN, first, nret+1, 0); } +/* +** Code a "conditional jump", that is, a test or comparison opcode +** followed by a jump. Return jump position. +*/ static int condjump (FuncState *fs, OpCode op, int A, int B, int C) { luaK_codeABC(fs, op, A, B, C); return luaK_jump(fs); } -static void fixjump (FuncState *fs, int pc, int dest) { - Instruction *jmp = &fs->f->code[pc]; - int offset = dest-(pc+1); - lua_assert(dest != NO_JUMP); - if (abs(offset) > MAXARG_sBx) - luaX_syntaxerror(fs->ls, "control structure too long"); - SETARG_sBx(*jmp, offset); -} - - /* -** returns current `pc' and marks it as a jump target (to avoid wrong +** returns current 'pc' and marks it as a jump target (to avoid wrong ** optimizations with consecutive instructions not in the same basic block). */ int luaK_getlabel (FuncState *fs) { @@ -97,15 +171,11 @@ int luaK_getlabel (FuncState *fs) { } -static int getjump (FuncState *fs, int pc) { - int offset = GETARG_sBx(fs->f->code[pc]); - if (offset == NO_JUMP) /* point to itself represents end of list */ - return NO_JUMP; /* end of list */ - else - return (pc+1)+offset; /* turn offset into absolute position */ -} - - +/* +** Returns the position of the instruction "controlling" a given +** jump (that is, its condition), or the jump itself if it is +** unconditional. +*/ static Instruction *getjumpcontrol (FuncState *fs, int pc) { Instruction *pi = &fs->f->code[pc]; if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1)))) @@ -116,37 +186,41 @@ static Instruction *getjumpcontrol (FuncState *fs, int pc) { /* -** check whether list has any jump that do not produce a value -** (or produce an inverted value) +** Patch destination register for a TESTSET instruction. +** If instruction in position 'node' is not a TESTSET, return 0 ("fails"). +** Otherwise, if 'reg' is not 'NO_REG', set it as the destination +** register. Otherwise, change instruction to a simple 'TEST' (produces +** no register value) */ -static int need_value (FuncState *fs, int list) { - for (; list != NO_JUMP; list = getjump(fs, list)) { - Instruction i = *getjumpcontrol(fs, list); - if (GET_OPCODE(i) != OP_TESTSET) return 1; - } - return 0; /* not found */ -} - - static int patchtestreg (FuncState *fs, int node, int reg) { Instruction *i = getjumpcontrol(fs, node); if (GET_OPCODE(*i) != OP_TESTSET) return 0; /* cannot patch other instructions */ if (reg != NO_REG && reg != GETARG_B(*i)) SETARG_A(*i, reg); - else /* no register to put value or register already has the value */ + else { + /* no register to put value or register already has the value; + change instruction to simple test */ *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i)); - + } return 1; } +/* +** Traverse a list of tests ensuring no one produces a value +*/ static void removevalues (FuncState *fs, int list) { for (; list != NO_JUMP; list = getjump(fs, list)) patchtestreg(fs, list, NO_REG); } +/* +** Traverse a list of tests, patching their destination address and +** registers: tests producing values jump to 'vtarget' (and put their +** values in 'reg'), other tests jump to 'dtarget'. +*/ static void patchlistaux (FuncState *fs, int list, int vtarget, int reg, int dtarget) { while (list != NO_JUMP) { @@ -160,15 +234,35 @@ static void patchlistaux (FuncState *fs, int list, int vtarget, int reg, } +/* +** Ensure all pending jumps to current position are fixed (jumping +** to current position with no values) and reset list of pending +** jumps +*/ static void dischargejpc (FuncState *fs) { patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc); fs->jpc = NO_JUMP; } +/* +** Add elements in 'list' to list of pending jumps to "here" +** (current position) +*/ +void luaK_patchtohere (FuncState *fs, int list) { + luaK_getlabel(fs); /* mark "here" as a jump target */ + luaK_concat(fs, &fs->jpc, list); +} + + +/* +** Path all jumps in 'list' to jump to 'target'. +** (The assert means that we cannot fix a jump to a forward address +** because we only know addresses once code is generated.) +*/ void luaK_patchlist (FuncState *fs, int list, int target) { - if (target == fs->pc) - luaK_patchtohere(fs, list); + if (target == fs->pc) /* 'target' is current position? */ + luaK_patchtohere(fs, list); /* add list to pending jumps */ else { lua_assert(target < fs->pc); patchlistaux(fs, list, target, NO_REG, target); @@ -176,42 +270,29 @@ void luaK_patchlist (FuncState *fs, int list, int target) { } -LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level) { +/* +** Path all jumps in 'list' to close upvalues up to given 'level' +** (The assertion checks that jumps either were closing nothing +** or were closing higher levels, from inner blocks.) +*/ +void luaK_patchclose (FuncState *fs, int list, int level) { level++; /* argument is +1 to reserve 0 as non-op */ - while (list != NO_JUMP) { - int next = getjump(fs, list); + for (; list != NO_JUMP; list = getjump(fs, list)) { lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP && (GETARG_A(fs->f->code[list]) == 0 || GETARG_A(fs->f->code[list]) >= level)); SETARG_A(fs->f->code[list], level); - list = next; - } -} - - -void luaK_patchtohere (FuncState *fs, int list) { - luaK_getlabel(fs); - luaK_concat(fs, &fs->jpc, list); -} - - -void luaK_concat (FuncState *fs, int *l1, int l2) { - if (l2 == NO_JUMP) return; - else if (*l1 == NO_JUMP) - *l1 = l2; - else { - int list = *l1; - int next; - while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */ - list = next; - fixjump(fs, list, l2); } } +/* +** Emit instruction 'i', checking for array sizes and saving also its +** line information. Return 'i' position. +*/ static int luaK_code (FuncState *fs, Instruction i) { Proto *f = fs->f; - dischargejpc(fs); /* `pc' will change */ + dischargejpc(fs); /* 'pc' will change */ /* put new instruction in code array */ luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, MAX_INT, "opcodes"); @@ -224,6 +305,10 @@ static int luaK_code (FuncState *fs, Instruction i) { } +/* +** Format and emit an 'iABC' instruction. (Assertions check consistency +** of parameters versus opcode.) +*/ int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) { lua_assert(getOpMode(o) == iABC); lua_assert(getBMode(o) != OpArgN || b == 0); @@ -233,6 +318,9 @@ int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) { } +/* +** Format and emit an 'iABx' instruction. +*/ int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) { lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx); lua_assert(getCMode(o) == OpArgN); @@ -241,12 +329,20 @@ int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) { } +/* +** Emit an "extra argument" instruction (format 'iAx') +*/ static int codeextraarg (FuncState *fs, int a) { lua_assert(a <= MAXARG_Ax); return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a)); } +/* +** Emit a "load constant" instruction, using either 'OP_LOADK' +** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX' +** instruction with "extra argument". +*/ int luaK_codek (FuncState *fs, int reg, int k) { if (k <= MAXARG_Bx) return luaK_codeABx(fs, OP_LOADK, reg, k); @@ -258,22 +354,35 @@ int luaK_codek (FuncState *fs, int reg, int k) { } +/* +** Check register-stack level, keeping track of its maximum size +** in field 'maxstacksize' +*/ void luaK_checkstack (FuncState *fs, int n) { int newstack = fs->freereg + n; if (newstack > fs->f->maxstacksize) { - if (newstack >= MAXSTACK) - luaX_syntaxerror(fs->ls, "function or expression too complex"); + if (newstack >= MAXREGS) + luaX_syntaxerror(fs->ls, + "function or expression needs too many registers"); fs->f->maxstacksize = cast_byte(newstack); } } +/* +** Reserve 'n' registers in register stack +*/ void luaK_reserveregs (FuncState *fs, int n) { luaK_checkstack(fs, n); fs->freereg += n; } +/* +** Free register 'reg', if it is neither a constant index nor +** a local variable. +) +*/ static void freereg (FuncState *fs, int reg) { if (!ISK(reg) && reg >= fs->nactvar) { fs->freereg--; @@ -282,31 +391,58 @@ static void freereg (FuncState *fs, int reg) { } +/* +** Free register used by expression 'e' (if any) +*/ static void freeexp (FuncState *fs, expdesc *e) { if (e->k == VNONRELOC) freereg(fs, e->u.info); } +/* +** Free registers used by expressions 'e1' and 'e2' (if any) in proper +** order. +*/ +static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) { + int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1; + int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1; + if (r1 > r2) { + freereg(fs, r1); + freereg(fs, r2); + } + else { + freereg(fs, r2); + freereg(fs, r1); + } +} + + +/* +** Add constant 'v' to prototype's list of constants (field 'k'). +** Use scanner's table to cache position of constants in constant list +** and try to reuse constants. Because some values should not be used +** as keys (nil cannot be a key, integer keys can collapse with float +** keys), the caller must provide a useful 'key' for indexing the cache. +*/ static int addk (FuncState *fs, TValue *key, TValue *v) { lua_State *L = fs->ls->L; - TValue *idx = luaH_set(L, fs->h, key); Proto *f = fs->f; + TValue *idx = luaH_set(L, fs->ls->h, key); /* index scanner table */ int k, oldsize; - if (ttisnumber(idx)) { - lua_Number n = nvalue(idx); - lua_number2int(k, n); - if (luaV_rawequalobj(&f->k[k], v)) - return k; - /* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0"); - go through and create a new entry for this value */ + if (ttisinteger(idx)) { /* is there an index there? */ + k = cast_int(ivalue(idx)); + /* correct value? (warning: must distinguish floats from integers!) */ + if (k < fs->nk && ttype(&f->k[k]) == ttype(v) && + luaV_rawequalobj(&f->k[k], v)) + return k; /* reuse index */ } /* constant not found; create a new entry */ oldsize = f->sizek; k = fs->nk; /* numerical value does not need GC barrier; table has no metatable, so it does not need to invalidate cache */ - setnvalue(idx, cast_num(k)); + setivalue(idx, k); luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); setobj(L, &f->k[k], v); @@ -316,94 +452,134 @@ static int addk (FuncState *fs, TValue *key, TValue *v) { } +/* +** Add a string to list of constants and return its index. +*/ int luaK_stringK (FuncState *fs, TString *s) { TValue o; setsvalue(fs->ls->L, &o, s); - return addk(fs, &o, &o); + return addk(fs, &o, &o); /* use string itself as key */ } -int luaK_numberK (FuncState *fs, lua_Number r) { - int n; - lua_State *L = fs->ls->L; +/* +** Add an integer to list of constants and return its index. +** Integers use userdata as keys to avoid collision with floats with +** same value; conversion to 'void*' is used only for hashing, so there +** are no "precision" problems. +*/ +int luaK_intK (FuncState *fs, lua_Integer n) { + TValue k, o; + setpvalue(&k, cast(void*, cast(size_t, n))); + setivalue(&o, n); + return addk(fs, &k, &o); +} + +/* +** Add a float to list of constants and return its index. +*/ +static int luaK_numberK (FuncState *fs, lua_Number r) { TValue o; - setnvalue(&o, r); - if (r == 0 || luai_numisnan(NULL, r)) { /* handle -0 and NaN */ - /* use raw representation as key to avoid numeric problems */ - setsvalue(L, L->top++, luaS_newlstr(L, (char *)&r, sizeof(r))); - n = addk(fs, L->top - 1, &o); - L->top--; - } - else - n = addk(fs, &o, &o); /* regular case */ - return n; + setfltvalue(&o, r); + return addk(fs, &o, &o); /* use number itself as key */ } +/* +** Add a boolean to list of constants and return its index. +*/ static int boolK (FuncState *fs, int b) { TValue o; setbvalue(&o, b); - return addk(fs, &o, &o); + return addk(fs, &o, &o); /* use boolean itself as key */ } +/* +** Add nil to list of constants and return its index. +*/ static int nilK (FuncState *fs) { TValue k, v; setnilvalue(&v); /* cannot use nil as key; instead use table itself to represent nil */ - sethvalue(fs->ls->L, &k, fs->h); + sethvalue(fs->ls->L, &k, fs->ls->h); return addk(fs, &k, &v); } +/* +** Fix an expression to return the number of results 'nresults'. +** Either 'e' is a multi-ret expression (function call or vararg) +** or 'nresults' is LUA_MULTRET (as any expression can satisfy that). +*/ void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { if (e->k == VCALL) { /* expression is an open function call? */ - SETARG_C(getcode(fs, e), nresults+1); + SETARG_C(getinstruction(fs, e), nresults + 1); } else if (e->k == VVARARG) { - SETARG_B(getcode(fs, e), nresults+1); - SETARG_A(getcode(fs, e), fs->freereg); + Instruction *pc = &getinstruction(fs, e); + SETARG_B(*pc, nresults + 1); + SETARG_A(*pc, fs->freereg); luaK_reserveregs(fs, 1); } + else lua_assert(nresults == LUA_MULTRET); } +/* +** Fix an expression to return one result. +** If expression is not a multi-ret expression (function call or +** vararg), it already returns one result, so nothing needs to be done. +** Function calls become VNONRELOC expressions (as its result comes +** fixed in the base register of the call), while vararg expressions +** become VRELOCABLE (as OP_VARARG puts its results where it wants). +** (Calls are created returning one result, so that does not need +** to be fixed.) +*/ void luaK_setoneret (FuncState *fs, expdesc *e) { if (e->k == VCALL) { /* expression is an open function call? */ - e->k = VNONRELOC; - e->u.info = GETARG_A(getcode(fs, e)); + /* already returns 1 value */ + lua_assert(GETARG_C(getinstruction(fs, e)) == 2); + e->k = VNONRELOC; /* result has fixed position */ + e->u.info = GETARG_A(getinstruction(fs, e)); } else if (e->k == VVARARG) { - SETARG_B(getcode(fs, e), 2); + SETARG_B(getinstruction(fs, e), 2); e->k = VRELOCABLE; /* can relocate its simple result */ } } +/* +** Ensure that expression 'e' is not a variable. +*/ void luaK_dischargevars (FuncState *fs, expdesc *e) { switch (e->k) { - case VLOCAL: { - e->k = VNONRELOC; + case VLOCAL: { /* already in a register */ + e->k = VNONRELOC; /* becomes a non-relocatable value */ break; } - case VUPVAL: { + case VUPVAL: { /* move value to some (pending) register */ e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); e->k = VRELOCABLE; break; } case VINDEXED: { - OpCode op = OP_GETTABUP; /* assume 't' is in an upvalue */ + OpCode op; freereg(fs, e->u.ind.idx); - if (e->u.ind.vt == VLOCAL) { /* 't' is in a register? */ + if (e->u.ind.vt == VLOCAL) { /* is 't' in a register? */ freereg(fs, e->u.ind.t); op = OP_GETTABLE; } + else { + lua_assert(e->u.ind.vt == VUPVAL); + op = OP_GETTABUP; /* 't' is in an upvalue */ + } e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx); e->k = VRELOCABLE; break; } - case VVARARG: - case VCALL: { + case VVARARG: case VCALL: { luaK_setoneret(fs, e); break; } @@ -412,12 +588,10 @@ void luaK_dischargevars (FuncState *fs, expdesc *e) { } -static int code_label (FuncState *fs, int A, int b, int jump) { - luaK_getlabel(fs); /* those instructions may be jump targets */ - return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump); -} - - +/* +** Ensures expression value is in register 'reg' (and therefore +** 'e' will become a non-relocatable expression). +*/ static void discharge2reg (FuncState *fs, expdesc *e, int reg) { luaK_dischargevars(fs, e); switch (e->k) { @@ -433,13 +607,17 @@ static void discharge2reg (FuncState *fs, expdesc *e, int reg) { luaK_codek(fs, reg, e->u.info); break; } - case VKNUM: { + case VKFLT: { luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval)); break; } + case VKINT: { + luaK_codek(fs, reg, luaK_intK(fs, e->u.ival)); + break; + } case VRELOCABLE: { - Instruction *pc = &getcode(fs, e); - SETARG_A(*pc, reg); + Instruction *pc = &getinstruction(fs, e); + SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ break; } case VNONRELOC: { @@ -448,7 +626,7 @@ static void discharge2reg (FuncState *fs, expdesc *e, int reg) { break; } default: { - lua_assert(e->k == VVOID || e->k == VJMP); + lua_assert(e->k == VJMP); return; /* nothing to do... */ } } @@ -457,26 +635,55 @@ static void discharge2reg (FuncState *fs, expdesc *e, int reg) { } +/* +** Ensures expression value is in any register. +*/ static void discharge2anyreg (FuncState *fs, expdesc *e) { - if (e->k != VNONRELOC) { - luaK_reserveregs(fs, 1); - discharge2reg(fs, e, fs->freereg-1); + if (e->k != VNONRELOC) { /* no fixed register yet? */ + luaK_reserveregs(fs, 1); /* get a register */ + discharge2reg(fs, e, fs->freereg-1); /* put value there */ } } +static int code_loadbool (FuncState *fs, int A, int b, int jump) { + luaK_getlabel(fs); /* those instructions may be jump targets */ + return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump); +} + + +/* +** check whether list has any jump that do not produce a value +** or produce an inverted value +*/ +static int need_value (FuncState *fs, int list) { + for (; list != NO_JUMP; list = getjump(fs, list)) { + Instruction i = *getjumpcontrol(fs, list); + if (GET_OPCODE(i) != OP_TESTSET) return 1; + } + return 0; /* not found */ +} + + +/* +** Ensures final expression result (including results from its jump +** lists) is in register 'reg'. +** If expression has jumps, need to patch these jumps either to +** its final position or to "load" instructions (for those tests +** that do not produce values). +*/ static void exp2reg (FuncState *fs, expdesc *e, int reg) { discharge2reg(fs, e, reg); - if (e->k == VJMP) - luaK_concat(fs, &e->t, e->u.info); /* put this jump in `t' list */ + if (e->k == VJMP) /* expression itself is a test? */ + luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ if (hasjumps(e)) { int final; /* position after whole expression */ int p_f = NO_JUMP; /* position of an eventual LOAD false */ int p_t = NO_JUMP; /* position of an eventual LOAD true */ if (need_value(fs, e->t) || need_value(fs, e->f)) { int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); - p_f = code_label(fs, reg, 0, 1); - p_t = code_label(fs, reg, 1, 0); + p_f = code_loadbool(fs, reg, 0, 1); + p_t = code_loadbool(fs, reg, 1, 0); luaK_patchtohere(fs, fj); } final = luaK_getlabel(fs); @@ -489,6 +696,10 @@ static void exp2reg (FuncState *fs, expdesc *e, int reg) { } +/* +** Ensures final expression result (including results from its jump +** lists) is in next available register. +*/ void luaK_exp2nextreg (FuncState *fs, expdesc *e) { luaK_dischargevars(fs, e); freeexp(fs, e); @@ -497,26 +708,39 @@ void luaK_exp2nextreg (FuncState *fs, expdesc *e) { } +/* +** Ensures final expression result (including results from its jump +** lists) is in some (any) register and return that register. +*/ int luaK_exp2anyreg (FuncState *fs, expdesc *e) { luaK_dischargevars(fs, e); - if (e->k == VNONRELOC) { - if (!hasjumps(e)) return e->u.info; /* exp is already in a register */ + if (e->k == VNONRELOC) { /* expression already has a register? */ + if (!hasjumps(e)) /* no jumps? */ + return e->u.info; /* result is already in a register */ if (e->u.info >= fs->nactvar) { /* reg. is not a local? */ - exp2reg(fs, e, e->u.info); /* put value on it */ + exp2reg(fs, e, e->u.info); /* put final result in it */ return e->u.info; } } - luaK_exp2nextreg(fs, e); /* default */ + luaK_exp2nextreg(fs, e); /* otherwise, use next available register */ return e->u.info; } +/* +** Ensures final expression result is either in a register or in an +** upvalue. +*/ void luaK_exp2anyregup (FuncState *fs, expdesc *e) { if (e->k != VUPVAL || hasjumps(e)) luaK_exp2anyreg(fs, e); } +/* +** Ensures final expression result is either in a register or it is +** a constant. +*/ void luaK_exp2val (FuncState *fs, expdesc *e) { if (hasjumps(e)) luaK_exp2anyreg(fs, e); @@ -525,29 +749,26 @@ void luaK_exp2val (FuncState *fs, expdesc *e) { } +/* +** Ensures final expression result is in a valid R/K index +** (that is, it is either in a register or in 'k' with an index +** in the range of R/K indices). +** Returns R/K index. +*/ int luaK_exp2RK (FuncState *fs, expdesc *e) { luaK_exp2val(fs, e); - switch (e->k) { - case VTRUE: - case VFALSE: - case VNIL: { - if (fs->nk <= MAXINDEXRK) { /* constant fits in RK operand? */ - e->u.info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE)); - e->k = VK; - return RKASK(e->u.info); - } - else break; - } - case VKNUM: { - e->u.info = luaK_numberK(fs, e->u.nval); + switch (e->k) { /* move constants to 'k' */ + case VTRUE: e->u.info = boolK(fs, 1); goto vk; + case VFALSE: e->u.info = boolK(fs, 0); goto vk; + case VNIL: e->u.info = nilK(fs); goto vk; + case VKINT: e->u.info = luaK_intK(fs, e->u.ival); goto vk; + case VKFLT: e->u.info = luaK_numberK(fs, e->u.nval); goto vk; + case VK: + vk: e->k = VK; - /* go through */ - } - case VK: { - if (e->u.info <= MAXINDEXRK) /* constant fits in argC? */ + if (e->u.info <= MAXINDEXRK) /* constant fits in 'argC'? */ return RKASK(e->u.info); else break; - } default: break; } /* not a constant in the right range: put it in a register */ @@ -555,11 +776,14 @@ int luaK_exp2RK (FuncState *fs, expdesc *e) { } +/* +** Generate code to store result of expression 'ex' into variable 'var'. +*/ void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { switch (var->k) { case VLOCAL: { freeexp(fs, ex); - exp2reg(fs, ex, var->u.info); + exp2reg(fs, ex, var->u.info); /* compute 'ex' into proper place */ return; } case VUPVAL: { @@ -573,29 +797,32 @@ void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { luaK_codeABC(fs, op, var->u.ind.t, var->u.ind.idx, e); break; } - default: { - lua_assert(0); /* invalid var kind to store */ - break; - } + default: lua_assert(0); /* invalid var kind to store */ } freeexp(fs, ex); } +/* +** Emit SELF instruction (convert expression 'e' into 'e:key(e,'). +*/ void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { int ereg; luaK_exp2anyreg(fs, e); ereg = e->u.info; /* register where 'e' was placed */ freeexp(fs, e); e->u.info = fs->freereg; /* base register for op_self */ - e->k = VNONRELOC; + e->k = VNONRELOC; /* self expression has a fixed register */ luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */ luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key)); freeexp(fs, key); } -static void invertjump (FuncState *fs, expdesc *e) { +/* +** Negate condition 'e' (where 'e' is a comparison). +*/ +static void negatecondition (FuncState *fs, expdesc *e) { Instruction *pc = getjumpcontrol(fs, e->u.info); lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET && GET_OPCODE(*pc) != OP_TEST); @@ -603,9 +830,15 @@ static void invertjump (FuncState *fs, expdesc *e) { } +/* +** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond' +** is true, code will jump if 'e' is true.) Return jump position. +** Optimize when 'e' is 'not' something, inverting the condition +** and removing the 'not'. +*/ static int jumponcond (FuncState *fs, expdesc *e, int cond) { if (e->k == VRELOCABLE) { - Instruction ie = getcode(fs, e); + Instruction ie = getinstruction(fs, e); if (GET_OPCODE(ie) == OP_NOT) { fs->pc--; /* remove previous OP_NOT */ return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond); @@ -618,36 +851,42 @@ static int jumponcond (FuncState *fs, expdesc *e, int cond) { } +/* +** Emit code to go through if 'e' is true, jump otherwise. +*/ void luaK_goiftrue (FuncState *fs, expdesc *e) { - int pc; /* pc of last jump */ + int pc; /* pc of new jump */ luaK_dischargevars(fs, e); switch (e->k) { - case VJMP: { - invertjump(fs, e); - pc = e->u.info; + case VJMP: { /* condition? */ + negatecondition(fs, e); /* jump when it is false */ + pc = e->u.info; /* save jump position */ break; } - case VK: case VKNUM: case VTRUE: { + case VK: case VKFLT: case VKINT: case VTRUE: { pc = NO_JUMP; /* always true; do nothing */ break; } default: { - pc = jumponcond(fs, e, 0); + pc = jumponcond(fs, e, 0); /* jump when false */ break; } } - luaK_concat(fs, &e->f, pc); /* insert last jump in `f' list */ - luaK_patchtohere(fs, e->t); + luaK_concat(fs, &e->f, pc); /* insert new jump in false list */ + luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */ e->t = NO_JUMP; } +/* +** Emit code to go through if 'e' is false, jump otherwise. +*/ void luaK_goiffalse (FuncState *fs, expdesc *e) { - int pc; /* pc of last jump */ + int pc; /* pc of new jump */ luaK_dischargevars(fs, e); switch (e->k) { case VJMP: { - pc = e->u.info; + pc = e->u.info; /* already jump if true */ break; } case VNIL: case VFALSE: { @@ -655,29 +894,32 @@ void luaK_goiffalse (FuncState *fs, expdesc *e) { break; } default: { - pc = jumponcond(fs, e, 1); + pc = jumponcond(fs, e, 1); /* jump if true */ break; } } - luaK_concat(fs, &e->t, pc); /* insert last jump in `t' list */ - luaK_patchtohere(fs, e->f); + luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */ + luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */ e->f = NO_JUMP; } +/* +** Code 'not e', doing constant folding. +*/ static void codenot (FuncState *fs, expdesc *e) { luaK_dischargevars(fs, e); switch (e->k) { case VNIL: case VFALSE: { - e->k = VTRUE; + e->k = VTRUE; /* true == not nil == not false */ break; } - case VK: case VKNUM: case VTRUE: { - e->k = VFALSE; + case VK: case VKFLT: case VKINT: case VTRUE: { + e->k = VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */ break; } case VJMP: { - invertjump(fs, e); + negatecondition(fs, e); break; } case VRELOCABLE: @@ -688,118 +930,181 @@ static void codenot (FuncState *fs, expdesc *e) { e->k = VRELOCABLE; break; } - default: { - lua_assert(0); /* cannot happen */ - break; - } + default: lua_assert(0); /* cannot happen */ } /* interchange true and false lists */ { int temp = e->f; e->f = e->t; e->t = temp; } - removevalues(fs, e->f); + removevalues(fs, e->f); /* values are useless when negated */ removevalues(fs, e->t); } +/* +** Create expression 't[k]'. 't' must have its final result already in a +** register or upvalue. +*/ void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { - lua_assert(!hasjumps(t)); - t->u.ind.t = t->u.info; - t->u.ind.idx = luaK_exp2RK(fs, k); - t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL - : check_exp(vkisinreg(t->k), VLOCAL); + lua_assert(!hasjumps(t) && (vkisinreg(t->k) || t->k == VUPVAL)); + t->u.ind.t = t->u.info; /* register or upvalue index */ + t->u.ind.idx = luaK_exp2RK(fs, k); /* R/K index for key */ + t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL : VLOCAL; t->k = VINDEXED; } -static int constfolding (OpCode op, expdesc *e1, expdesc *e2) { - lua_Number r; - if (!isnumeral(e1) || !isnumeral(e2)) return 0; - if ((op == OP_DIV || op == OP_MOD) && e2->u.nval == 0) - return 0; /* do not attempt to divide by 0 */ - r = luaO_arith(op - OP_ADD + LUA_OPADD, e1->u.nval, e2->u.nval); - e1->u.nval = r; - return 1; +/* +** Return false if folding can raise an error. +** Bitwise operations need operands convertible to integers; division +** operations cannot have 0 as divisor. +*/ +static int validop (int op, TValue *v1, TValue *v2) { + switch (op) { + case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: + case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ + lua_Integer i; + return (tointeger(v1, &i) && tointeger(v2, &i)); + } + case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ + return (nvalue(v2) != 0); + default: return 1; /* everything else is valid */ + } } -static void codearith (FuncState *fs, OpCode op, - expdesc *e1, expdesc *e2, int line) { - if (constfolding(op, e1, e2)) - return; - else { - int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0; - int o1 = luaK_exp2RK(fs, e1); - if (o1 > o2) { - freeexp(fs, e1); - freeexp(fs, e2); - } - else { - freeexp(fs, e2); - freeexp(fs, e1); - } - e1->u.info = luaK_codeABC(fs, op, 0, o1, o2); - e1->k = VRELOCABLE; - luaK_fixline(fs, line); +/* +** Try to "constant-fold" an operation; return 1 iff successful. +** (In this case, 'e1' has the final result.) +*/ +static int constfolding (FuncState *fs, int op, expdesc *e1, + const expdesc *e2) { + TValue v1, v2, res; + if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2)) + return 0; /* non-numeric operands or not safe to fold */ + luaO_arith(fs->ls->L, op, &v1, &v2, &res); /* does operation */ + if (ttisinteger(&res)) { + e1->k = VKINT; + e1->u.ival = ivalue(&res); } + else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */ + lua_Number n = fltvalue(&res); + if (luai_numisnan(n) || n == 0) + return 0; + e1->k = VKFLT; + e1->u.nval = n; + } + return 1; } -static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1, - expdesc *e2) { - int o1 = luaK_exp2RK(fs, e1); - int o2 = luaK_exp2RK(fs, e2); - freeexp(fs, e2); - freeexp(fs, e1); - if (cond == 0 && op != OP_EQ) { - int temp; /* exchange args to replace by `<' or `<=' */ - temp = o1; o1 = o2; o2 = temp; /* o1 <==> o2 */ - cond = 1; +/* +** Emit code for unary expressions that "produce values" +** (everything but 'not'). +** Expression to produce final result will be encoded in 'e'. +*/ +static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) { + int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */ + freeexp(fs, e); + e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */ + e->k = VRELOCABLE; /* all those operations are relocatable */ + luaK_fixline(fs, line); +} + + +/* +** Emit code for binary expressions that "produce values" +** (everything but logical operators 'and'/'or' and comparison +** operators). +** Expression to produce final result will be encoded in 'e1'. +** Because 'luaK_exp2RK' can free registers, its calls must be +** in "stack order" (that is, first on 'e2', which may have more +** recent registers to be released). +*/ +static void codebinexpval (FuncState *fs, OpCode op, + expdesc *e1, expdesc *e2, int line) { + int rk2 = luaK_exp2RK(fs, e2); /* both operands are "RK" */ + int rk1 = luaK_exp2RK(fs, e1); + freeexps(fs, e1, e2); + e1->u.info = luaK_codeABC(fs, op, 0, rk1, rk2); /* generate opcode */ + e1->k = VRELOCABLE; /* all those operations are relocatable */ + luaK_fixline(fs, line); +} + + +/* +** Emit code for comparisons. +** 'e1' was already put in R/K form by 'luaK_infix'. +*/ +static void codecomp (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { + int rk1 = (e1->k == VK) ? RKASK(e1->u.info) + : check_exp(e1->k == VNONRELOC, e1->u.info); + int rk2 = luaK_exp2RK(fs, e2); + freeexps(fs, e1, e2); + switch (opr) { + case OPR_NE: { /* '(a ~= b)' ==> 'not (a == b)' */ + e1->u.info = condjump(fs, OP_EQ, 0, rk1, rk2); + break; + } + case OPR_GT: case OPR_GE: { + /* '(a > b)' ==> '(b < a)'; '(a >= b)' ==> '(b <= a)' */ + OpCode op = cast(OpCode, (opr - OPR_NE) + OP_EQ); + e1->u.info = condjump(fs, op, 1, rk2, rk1); /* invert operands */ + break; + } + default: { /* '==', '<', '<=' use their own opcodes */ + OpCode op = cast(OpCode, (opr - OPR_EQ) + OP_EQ); + e1->u.info = condjump(fs, op, 1, rk1, rk2); + break; + } } - e1->u.info = condjump(fs, op, cond, o1, o2); e1->k = VJMP; } +/* +** Apply prefix operation 'op' to expression 'e'. +*/ void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) { - expdesc e2; - e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0; + static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; switch (op) { - case OPR_MINUS: { - if (isnumeral(e)) /* minus constant? */ - e->u.nval = luai_numunm(NULL, e->u.nval); /* fold it */ - else { - luaK_exp2anyreg(fs, e); - codearith(fs, OP_UNM, e, &e2, line); - } + case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */ + if (constfolding(fs, op + LUA_OPUNM, e, &ef)) + break; + /* FALLTHROUGH */ + case OPR_LEN: + codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line); break; - } case OPR_NOT: codenot(fs, e); break; - case OPR_LEN: { - luaK_exp2anyreg(fs, e); /* cannot operate on constants */ - codearith(fs, OP_LEN, e, &e2, line); - break; - } default: lua_assert(0); } } +/* +** Process 1st operand 'v' of binary operation 'op' before reading +** 2nd operand. +*/ void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { switch (op) { case OPR_AND: { - luaK_goiftrue(fs, v); + luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ break; } case OPR_OR: { - luaK_goiffalse(fs, v); + luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ break; } case OPR_CONCAT: { - luaK_exp2nextreg(fs, v); /* operand must be on the `stack' */ + luaK_exp2nextreg(fs, v); /* operand must be on the 'stack' */ break; } - case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV: - case OPR_MOD: case OPR_POW: { - if (!isnumeral(v)) luaK_exp2RK(fs, v); + case OPR_ADD: case OPR_SUB: + case OPR_MUL: case OPR_DIV: case OPR_IDIV: + case OPR_MOD: case OPR_POW: + case OPR_BAND: case OPR_BOR: case OPR_BXOR: + case OPR_SHL: case OPR_SHR: { + if (!tonumeral(v, NULL)) + luaK_exp2RK(fs, v); + /* else keep numeral, which may be folded with 2nd operand */ break; } default: { @@ -810,18 +1115,24 @@ void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { } +/* +** Finalize code for binary operation, after reading 2nd operand. +** For '(a .. b .. c)' (which is '(a .. (b .. c))', because +** concatenation is right associative), merge second CONCAT into first +** one. +*/ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2, int line) { switch (op) { case OPR_AND: { - lua_assert(e1->t == NO_JUMP); /* list must be closed */ + lua_assert(e1->t == NO_JUMP); /* list closed by 'luK_infix' */ luaK_dischargevars(fs, e2); luaK_concat(fs, &e2->f, e1->f); *e1 = *e2; break; } case OPR_OR: { - lua_assert(e1->f == NO_JUMP); /* list must be closed */ + lua_assert(e1->f == NO_JUMP); /* list closed by 'luK_infix' */ luaK_dischargevars(fs, e2); luaK_concat(fs, &e2->t, e1->t); *e1 = *e2; @@ -829,29 +1140,30 @@ void luaK_posfix (FuncState *fs, BinOpr op, } case OPR_CONCAT: { luaK_exp2val(fs, e2); - if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) { - lua_assert(e1->u.info == GETARG_B(getcode(fs, e2))-1); + if (e2->k == VRELOCABLE && + GET_OPCODE(getinstruction(fs, e2)) == OP_CONCAT) { + lua_assert(e1->u.info == GETARG_B(getinstruction(fs, e2))-1); freeexp(fs, e1); - SETARG_B(getcode(fs, e2), e1->u.info); + SETARG_B(getinstruction(fs, e2), e1->u.info); e1->k = VRELOCABLE; e1->u.info = e2->u.info; } else { luaK_exp2nextreg(fs, e2); /* operand must be on the 'stack' */ - codearith(fs, OP_CONCAT, e1, e2, line); + codebinexpval(fs, OP_CONCAT, e1, e2, line); } break; } case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV: - case OPR_MOD: case OPR_POW: { - codearith(fs, cast(OpCode, op - OPR_ADD + OP_ADD), e1, e2, line); - break; - } - case OPR_EQ: case OPR_LT: case OPR_LE: { - codecomp(fs, cast(OpCode, op - OPR_EQ + OP_EQ), 1, e1, e2); + case OPR_IDIV: case OPR_MOD: case OPR_POW: + case OPR_BAND: case OPR_BOR: case OPR_BXOR: + case OPR_SHL: case OPR_SHR: { + if (!constfolding(fs, op + LUA_OPADD, e1, e2)) + codebinexpval(fs, cast(OpCode, op + OP_ADD), e1, e2, line); break; } + case OPR_EQ: case OPR_LT: case OPR_LE: case OPR_NE: case OPR_GT: case OPR_GE: { - codecomp(fs, cast(OpCode, op - OPR_NE + OP_EQ), 0, e1, e2); + codecomp(fs, op, e1, e2); break; } default: lua_assert(0); @@ -859,15 +1171,25 @@ void luaK_posfix (FuncState *fs, BinOpr op, } +/* +** Change line information associated with current position. +*/ void luaK_fixline (FuncState *fs, int line) { fs->f->lineinfo[fs->pc - 1] = line; } +/* +** Emit a SETLIST instruction. +** 'base' is register that keeps table; +** 'nelems' is #table plus those to be stored now; +** 'tostore' is number of values (in registers 'base + 1',...) to add to +** table (or LUA_MULTRET to add up to stack top). +*/ void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) { int c = (nelems - 1)/LFIELDS_PER_FLUSH + 1; int b = (tostore == LUA_MULTRET) ? 0 : tostore; - lua_assert(tostore != 0); + lua_assert(tostore != 0 && tostore <= LFIELDS_PER_FLUSH); if (c <= MAXARG_C) luaK_codeABC(fs, OP_SETLIST, base, b, c); else if (c <= MAXARG_Ax) { diff --git a/depends/lua/src/lcorolib.c b/depends/lua/src/lcorolib.c index ce4f6ad42c..0b17af9e34 100644 --- a/depends/lua/src/lcorolib.c +++ b/depends/lua/src/lcorolib.c @@ -1,15 +1,16 @@ /* -** $Id: lcorolib.c,v 1.5.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lcorolib.c,v 1.10.1.1 2017/04/19 17:20:42 roberto Exp $ ** Coroutine Library ** See Copyright Notice in lua.h */ +#define lcorolib_c +#define LUA_LIB -#include +#include "lprefix.h" -#define lcorolib_c -#define LUA_LIB +#include #include "lua.h" @@ -17,6 +18,13 @@ #include "lualib.h" +static lua_State *getco (lua_State *L) { + lua_State *co = lua_tothread(L, 1); + luaL_argcheck(L, co, 1, "thread expected"); + return co; +} + + static int auxresume (lua_State *L, lua_State *co, int narg) { int status; if (!lua_checkstack(co, narg)) { @@ -47,9 +55,8 @@ static int auxresume (lua_State *L, lua_State *co, int narg) { static int luaB_coresume (lua_State *L) { - lua_State *co = lua_tothread(L, 1); + lua_State *co = getco(L); int r; - luaL_argcheck(L, co, 1, "coroutine expected"); r = auxresume(L, co, lua_gettop(L) - 1); if (r < 0) { lua_pushboolean(L, 0); @@ -59,7 +66,7 @@ static int luaB_coresume (lua_State *L) { else { lua_pushboolean(L, 1); lua_insert(L, -(r + 1)); - return r + 1; /* return true + `resume' returns */ + return r + 1; /* return true + 'resume' returns */ } } @@ -68,7 +75,7 @@ static int luaB_auxwrap (lua_State *L) { lua_State *co = lua_tothread(L, lua_upvalueindex(1)); int r = auxresume(L, co, lua_gettop(L)); if (r < 0) { - if (lua_isstring(L, -1)) { /* error object is a string? */ + if (lua_type(L, -1) == LUA_TSTRING) { /* error object is a string? */ luaL_where(L, 1); /* add extra info */ lua_insert(L, -2); lua_concat(L, 2); @@ -102,8 +109,7 @@ static int luaB_yield (lua_State *L) { static int luaB_costatus (lua_State *L) { - lua_State *co = lua_tothread(L, 1); - luaL_argcheck(L, co, 1, "coroutine expected"); + lua_State *co = getco(L); if (L == co) lua_pushliteral(L, "running"); else { switch (lua_status(co)) { @@ -129,6 +135,12 @@ static int luaB_costatus (lua_State *L) { } +static int luaB_yieldable (lua_State *L) { + lua_pushboolean(L, lua_isyieldable(L)); + return 1; +} + + static int luaB_corunning (lua_State *L) { int ismain = lua_pushthread(L); lua_pushboolean(L, ismain); @@ -143,6 +155,7 @@ static const luaL_Reg co_funcs[] = { {"status", luaB_costatus}, {"wrap", luaB_cowrap}, {"yield", luaB_yield}, + {"isyieldable", luaB_yieldable}, {NULL, NULL} }; diff --git a/depends/lua/src/lctype.c b/depends/lua/src/lctype.c index 93f8cadc39..f8ad7a2edf 100644 --- a/depends/lua/src/lctype.c +++ b/depends/lua/src/lctype.c @@ -1,5 +1,5 @@ /* -** $Id: lctype.c,v 1.11.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lctype.c,v 1.12.1.1 2017/04/19 17:20:42 roberto Exp $ ** 'ctype' functions for Lua ** See Copyright Notice in lua.h */ @@ -7,6 +7,9 @@ #define lctype_c #define LUA_CORE +#include "lprefix.h" + + #include "lctype.h" #if !LUA_USE_CTYPE /* { */ diff --git a/depends/lua/src/ldblib.c b/depends/lua/src/ldblib.c index 84fe3c7d82..9d29afb0a8 100644 --- a/depends/lua/src/ldblib.c +++ b/depends/lua/src/ldblib.c @@ -1,26 +1,42 @@ /* -** $Id: ldblib.c,v 1.132.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: ldblib.c,v 1.151.1.1 2017/04/19 17:20:42 roberto Exp $ ** Interface from Lua to its debug API ** See Copyright Notice in lua.h */ +#define ldblib_c +#define LUA_LIB + +#include "lprefix.h" + #include #include #include -#define ldblib_c -#define LUA_LIB - #include "lua.h" #include "lauxlib.h" #include "lualib.h" -#define HOOKKEY "_HKEY" +/* +** The hook table at registry[&HOOKKEY] maps threads to their current +** hook function. (We only need the unique address of 'HOOKKEY'.) +*/ +static const int HOOKKEY = 0; +/* +** If L1 != L, L1 can be in any state, and therefore there are no +** guarantees about its stack space; any push in L1 must be +** checked. +*/ +static void checkstack (lua_State *L, lua_State *L1, int n) { + if (L != L1 && !lua_checkstack(L1, n)) + luaL_error(L, "stack overflow"); +} + static int db_getregistry (lua_State *L) { lua_pushvalue(L, LUA_REGISTRYINDEX); @@ -57,35 +73,20 @@ static int db_getuservalue (lua_State *L) { static int db_setuservalue (lua_State *L) { - if (lua_type(L, 1) == LUA_TLIGHTUSERDATA) - luaL_argerror(L, 1, "full userdata expected, got light userdata"); luaL_checktype(L, 1, LUA_TUSERDATA); - if (!lua_isnoneornil(L, 2)) - luaL_checktype(L, 2, LUA_TTABLE); + luaL_checkany(L, 2); lua_settop(L, 2); lua_setuservalue(L, 1); return 1; } -static void settabss (lua_State *L, const char *i, const char *v) { - lua_pushstring(L, v); - lua_setfield(L, -2, i); -} - - -static void settabsi (lua_State *L, const char *i, int v) { - lua_pushinteger(L, v); - lua_setfield(L, -2, i); -} - - -static void settabsb (lua_State *L, const char *i, int v) { - lua_pushboolean(L, v); - lua_setfield(L, -2, i); -} - - +/* +** Auxiliary function used by several library functions: check for +** an optional thread as function's first argument and set 'arg' with +** 1 if this argument is present (so that functions can skip it to +** access their other arguments) +*/ static lua_State *getthread (lua_State *L, int *arg) { if (lua_isthread(L, 1)) { *arg = 1; @@ -93,44 +94,74 @@ static lua_State *getthread (lua_State *L, int *arg) { } else { *arg = 0; - return L; + return L; /* function will operate over current thread */ } } +/* +** Variations of 'lua_settable', used by 'db_getinfo' to put results +** from 'lua_getinfo' into result table. Key is always a string; +** value can be a string, an int, or a boolean. +*/ +static void settabss (lua_State *L, const char *k, const char *v) { + lua_pushstring(L, v); + lua_setfield(L, -2, k); +} + +static void settabsi (lua_State *L, const char *k, int v) { + lua_pushinteger(L, v); + lua_setfield(L, -2, k); +} + +static void settabsb (lua_State *L, const char *k, int v) { + lua_pushboolean(L, v); + lua_setfield(L, -2, k); +} + + +/* +** In function 'db_getinfo', the call to 'lua_getinfo' may push +** results on the stack; later it creates the result table to put +** these objects. Function 'treatstackoption' puts the result from +** 'lua_getinfo' on top of the result table so that it can call +** 'lua_setfield'. +*/ static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) { - if (L == L1) { - lua_pushvalue(L, -2); - lua_remove(L, -3); - } + if (L == L1) + lua_rotate(L, -2, 1); /* exchange object and table */ else - lua_xmove(L1, L, 1); - lua_setfield(L, -2, fname); + lua_xmove(L1, L, 1); /* move object to the "main" stack */ + lua_setfield(L, -2, fname); /* put object into table */ } +/* +** Calls 'lua_getinfo' and collects all results in a new table. +** L1 needs stack space for an optional input (function) plus +** two optional outputs (function and line table) from function +** 'lua_getinfo'. +*/ static int db_getinfo (lua_State *L) { lua_Debug ar; int arg; lua_State *L1 = getthread(L, &arg); const char *options = luaL_optstring(L, arg+2, "flnStu"); - if (lua_isnumber(L, arg+1)) { - if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) { + checkstack(L, L1, 3); + if (lua_isfunction(L, arg + 1)) { /* info about a function? */ + options = lua_pushfstring(L, ">%s", options); /* add '>' to 'options' */ + lua_pushvalue(L, arg + 1); /* move function to 'L1' stack */ + lua_xmove(L, L1, 1); + } + else { /* stack level */ + if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) { lua_pushnil(L); /* level out of range */ return 1; } } - else if (lua_isfunction(L, arg+1)) { - lua_pushfstring(L, ">%s", options); - options = lua_tostring(L, -1); - lua_pushvalue(L, arg+1); - lua_xmove(L, L1, 1); - } - else - return luaL_argerror(L, arg+1, "function or level expected"); if (!lua_getinfo(L1, options, &ar)) return luaL_argerror(L, arg+2, "invalid option"); - lua_createtable(L, 0, 2); + lua_newtable(L); /* table to collect results */ if (strchr(options, 'S')) { settabss(L, "source", ar.source); settabss(L, "short_src", ar.short_src); @@ -164,20 +195,22 @@ static int db_getlocal (lua_State *L) { lua_State *L1 = getthread(L, &arg); lua_Debug ar; const char *name; - int nvar = luaL_checkint(L, arg+2); /* local-variable index */ + int nvar = (int)luaL_checkinteger(L, arg + 2); /* local-variable index */ if (lua_isfunction(L, arg + 1)) { /* function argument? */ lua_pushvalue(L, arg + 1); /* push function */ lua_pushstring(L, lua_getlocal(L, NULL, nvar)); /* push local name */ - return 1; + return 1; /* return only name (there is no value) */ } else { /* stack-level argument */ - if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */ + int level = (int)luaL_checkinteger(L, arg + 1); + if (!lua_getstack(L1, level, &ar)) /* out of range? */ return luaL_argerror(L, arg+1, "level out of range"); + checkstack(L, L1, 1); name = lua_getlocal(L1, &ar, nvar); if (name) { - lua_xmove(L1, L, 1); /* push local value */ + lua_xmove(L1, L, 1); /* move local value */ lua_pushstring(L, name); /* push name */ - lua_pushvalue(L, -2); /* re-order */ + lua_rotate(L, -2, 1); /* re-order */ return 2; } else { @@ -190,26 +223,36 @@ static int db_getlocal (lua_State *L) { static int db_setlocal (lua_State *L) { int arg; + const char *name; lua_State *L1 = getthread(L, &arg); lua_Debug ar; - if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */ + int level = (int)luaL_checkinteger(L, arg + 1); + int nvar = (int)luaL_checkinteger(L, arg + 2); + if (!lua_getstack(L1, level, &ar)) /* out of range? */ return luaL_argerror(L, arg+1, "level out of range"); luaL_checkany(L, arg+3); lua_settop(L, arg+3); + checkstack(L, L1, 1); lua_xmove(L, L1, 1); - lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2))); + name = lua_setlocal(L1, &ar, nvar); + if (name == NULL) + lua_pop(L1, 1); /* pop value (if not popped by 'lua_setlocal') */ + lua_pushstring(L, name); return 1; } +/* +** get (if 'get' is true) or set an upvalue from a closure +*/ static int auxupvalue (lua_State *L, int get) { const char *name; - int n = luaL_checkint(L, 2); - luaL_checktype(L, 1, LUA_TFUNCTION); + int n = (int)luaL_checkinteger(L, 2); /* upvalue index */ + luaL_checktype(L, 1, LUA_TFUNCTION); /* closure */ name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n); if (name == NULL) return 0; lua_pushstring(L, name); - lua_insert(L, -(get+1)); + lua_insert(L, -(get+1)); /* no-op if get is false */ return get + 1; } @@ -225,13 +268,15 @@ static int db_setupvalue (lua_State *L) { } +/* +** Check whether a given upvalue from a given closure exists and +** returns its index +*/ static int checkupval (lua_State *L, int argf, int argnup) { - lua_Debug ar; - int nup = luaL_checkint(L, argnup); - luaL_checktype(L, argf, LUA_TFUNCTION); - lua_pushvalue(L, argf); - lua_getinfo(L, ">u", &ar); - luaL_argcheck(L, 1 <= nup && nup <= ar.nups, argnup, "invalid upvalue index"); + int nup = (int)luaL_checkinteger(L, argnup); /* upvalue index */ + luaL_checktype(L, argf, LUA_TFUNCTION); /* closure */ + luaL_argcheck(L, (lua_getupvalue(L, argf, nup) != NULL), argnup, + "invalid upvalue index"); return nup; } @@ -253,26 +298,29 @@ static int db_upvaluejoin (lua_State *L) { } -#define gethooktable(L) luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY) - - +/* +** Call hook function registered at hook table for the current +** thread (if there is one) +*/ static void hookf (lua_State *L, lua_Debug *ar) { static const char *const hooknames[] = {"call", "return", "line", "count", "tail call"}; - gethooktable(L); + lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY); lua_pushthread(L); - lua_rawget(L, -2); - if (lua_isfunction(L, -1)) { - lua_pushstring(L, hooknames[(int)ar->event]); + if (lua_rawget(L, -2) == LUA_TFUNCTION) { /* is there a hook function? */ + lua_pushstring(L, hooknames[(int)ar->event]); /* push event name */ if (ar->currentline >= 0) - lua_pushinteger(L, ar->currentline); + lua_pushinteger(L, ar->currentline); /* push current line */ else lua_pushnil(L); lua_assert(lua_getinfo(L, "lS", ar)); - lua_call(L, 2, 0); + lua_call(L, 2, 0); /* call hook function */ } } +/* +** Convert a string mask (for 'sethook') into a bit mask +*/ static int makemask (const char *smask, int count) { int mask = 0; if (strchr(smask, 'c')) mask |= LUA_MASKCALL; @@ -283,6 +331,9 @@ static int makemask (const char *smask, int count) { } +/* +** Convert a bit mask (for 'gethook') into a string mask +*/ static char *unmakemask (int mask, char *smask) { int i = 0; if (mask & LUA_MASKCALL) smask[i++] = 'c'; @@ -297,26 +348,30 @@ static int db_sethook (lua_State *L) { int arg, mask, count; lua_Hook func; lua_State *L1 = getthread(L, &arg); - if (lua_isnoneornil(L, arg+1)) { + if (lua_isnoneornil(L, arg+1)) { /* no hook? */ lua_settop(L, arg+1); func = NULL; mask = 0; count = 0; /* turn off hooks */ } else { const char *smask = luaL_checkstring(L, arg+2); luaL_checktype(L, arg+1, LUA_TFUNCTION); - count = luaL_optint(L, arg+3, 0); + count = (int)luaL_optinteger(L, arg + 3, 0); func = hookf; mask = makemask(smask, count); } - if (gethooktable(L) == 0) { /* creating hook table? */ + if (lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY) == LUA_TNIL) { + lua_createtable(L, 0, 2); /* create a hook table */ + lua_pushvalue(L, -1); + lua_rawsetp(L, LUA_REGISTRYINDEX, &HOOKKEY); /* set it in position */ lua_pushstring(L, "k"); lua_setfield(L, -2, "__mode"); /** hooktable.__mode = "k" */ lua_pushvalue(L, -1); lua_setmetatable(L, -2); /* setmetatable(hooktable) = hooktable */ } - lua_pushthread(L1); lua_xmove(L1, L, 1); - lua_pushvalue(L, arg+1); - lua_rawset(L, -3); /* set new hook */ - lua_sethook(L1, func, mask, count); /* set hooks */ + checkstack(L, L1, 1); + lua_pushthread(L1); lua_xmove(L1, L, 1); /* key (thread) */ + lua_pushvalue(L, arg + 1); /* value (hook function) */ + lua_rawset(L, -3); /* hooktable[L1] = new Lua hook */ + lua_sethook(L1, func, mask, count); return 0; } @@ -327,16 +382,19 @@ static int db_gethook (lua_State *L) { char buff[5]; int mask = lua_gethookmask(L1); lua_Hook hook = lua_gethook(L1); - if (hook != NULL && hook != hookf) /* external hook? */ + if (hook == NULL) /* no hook? */ + lua_pushnil(L); + else if (hook != hookf) /* external hook? */ lua_pushliteral(L, "external hook"); - else { - gethooktable(L); + else { /* hook table must exist */ + lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY); + checkstack(L, L1, 1); lua_pushthread(L1); lua_xmove(L1, L, 1); - lua_rawget(L, -2); /* get hook */ + lua_rawget(L, -2); /* 1st result = hooktable[L1] */ lua_remove(L, -2); /* remove hook table */ } - lua_pushstring(L, unmakemask(mask, buff)); - lua_pushinteger(L, lua_gethookcount(L1)); + lua_pushstring(L, unmakemask(mask, buff)); /* 2nd result = mask */ + lua_pushinteger(L, lua_gethookcount(L1)); /* 3rd result = count */ return 3; } @@ -344,13 +402,13 @@ static int db_gethook (lua_State *L) { static int db_debug (lua_State *L) { for (;;) { char buffer[250]; - luai_writestringerror("%s", "lua_debug> "); + lua_writestringerror("%s", "lua_debug> "); if (fgets(buffer, sizeof(buffer), stdin) == 0 || strcmp(buffer, "cont\n") == 0) return 0; if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") || lua_pcall(L, 0, 0, 0)) - luai_writestringerror("%s\n", lua_tostring(L, -1)); + lua_writestringerror("%s\n", lua_tostring(L, -1)); lua_settop(L, 0); /* remove eventual returns */ } } @@ -363,7 +421,7 @@ static int db_traceback (lua_State *L) { if (msg == NULL && !lua_isnoneornil(L, arg + 1)) /* non-string 'msg'? */ lua_pushvalue(L, arg + 1); /* return it untouched */ else { - int level = luaL_optint(L, arg + 2, (L == L1) ? 1 : 0); + int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0); luaL_traceback(L, L1, msg, level); } return 1; diff --git a/depends/lua/src/ldebug.c b/depends/lua/src/ldebug.c index 20d663efff..bb0e1d4ace 100644 --- a/depends/lua/src/ldebug.c +++ b/depends/lua/src/ldebug.c @@ -1,18 +1,19 @@ /* -** $Id: ldebug.c,v 2.90.1.3 2013/05/16 16:04:15 roberto Exp $ +** $Id: ldebug.c,v 2.121.1.2 2017/07/10 17:21:50 roberto Exp $ ** Debug Interface ** See Copyright Notice in lua.h */ +#define ldebug_c +#define LUA_CORE + +#include "lprefix.h" + #include #include #include - -#define ldebug_c -#define LUA_CORE - #include "lua.h" #include "lapi.h" @@ -33,7 +34,12 @@ #define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_TCCL) -static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name); +/* Active Lua function (given call info) */ +#define ci_func(ci) (clLvalue((ci)->func)) + + +static const char *funcnamefromcode (lua_State *L, CallInfo *ci, + const char **name); static int currentpc (CallInfo *ci) { @@ -48,9 +54,31 @@ static int currentline (CallInfo *ci) { /* -** this function can be called asynchronous (e.g. during a signal) +** If function yielded, its 'func' can be in the 'extra' field. The +** next function restores 'func' to its correct value for debugging +** purposes. (It exchanges 'func' and 'extra'; so, when called again, +** after debugging, it also "re-restores" ** 'func' to its altered value. +*/ +static void swapextra (lua_State *L) { + if (L->status == LUA_YIELD) { + CallInfo *ci = L->ci; /* get function that yielded */ + StkId temp = ci->func; /* exchange its 'func' and 'extra' values */ + ci->func = restorestack(L, ci->extra); + ci->extra = savestack(L, temp); + } +} + + +/* +** This function can be called asynchronously (e.g. during a signal). +** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by +** 'resethookcount') are for debug only, and it is no problem if they +** get arbitrary values (causes at most one wrong hook call). 'hookmask' +** is an atomic value. We assume that pointers are atomic too (e.g., gcc +** ensures that for all platforms where it runs). Moreover, 'hook' is +** always checked before being called (see 'luaD_hook'). */ -LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) { +LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) { if (func == NULL || mask == 0) { /* turn off hooks? */ mask = 0; func = NULL; @@ -61,7 +89,6 @@ LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) { L->basehookcount = count; resethookcount(L); L->hookmask = cast_byte(mask); - return 1; } @@ -106,10 +133,11 @@ static const char *upvalname (Proto *p, int uv) { static const char *findvararg (CallInfo *ci, int n, StkId *pos) { int nparams = clLvalue(ci->func)->p->numparams; - if (n >= ci->u.l.base - ci->func - nparams) + int nvararg = cast_int(ci->u.l.base - ci->func) - nparams; + if (n <= -nvararg) return NULL; /* no such vararg */ else { - *pos = ci->func + nparams + n; + *pos = ci->func + nparams - n; return "(*vararg)"; /* generic name for any vararg */ } } @@ -121,7 +149,7 @@ static const char *findlocal (lua_State *L, CallInfo *ci, int n, StkId base; if (isLua(ci)) { if (n < 0) /* access to vararg values? */ - return findvararg(ci, -n, pos); + return findvararg(ci, n, pos); else { base = ci->u.l.base; name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci)); @@ -144,6 +172,7 @@ static const char *findlocal (lua_State *L, CallInfo *ci, int n, LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { const char *name; lua_lock(L); + swapextra(L); if (ar == NULL) { /* information about non-active function? */ if (!isLfunction(L->top - 1)) /* not a Lua function? */ name = NULL; @@ -151,25 +180,30 @@ LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { name = luaF_getlocalname(clLvalue(L->top - 1)->p, n, 0); } else { /* active function; get information through 'ar' */ - StkId pos = 0; /* to avoid warnings */ + StkId pos = NULL; /* to avoid warnings */ name = findlocal(L, ar->i_ci, n, &pos); if (name) { setobj2s(L, L->top, pos); api_incr_top(L); } } + swapextra(L); lua_unlock(L); return name; } LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { - StkId pos = 0; /* to avoid warnings */ - const char *name = findlocal(L, ar->i_ci, n, &pos); + StkId pos = NULL; /* to avoid warnings */ + const char *name; lua_lock(L); - if (name) + swapextra(L); + name = findlocal(L, ar->i_ci, n, &pos); + if (name) { setobjs2s(L, pos, L->top - 1); - L->top--; /* pop value */ + L->top--; /* pop value */ + } + swapextra(L); lua_unlock(L); return name; } @@ -212,6 +246,20 @@ static void collectvalidlines (lua_State *L, Closure *f) { } +static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { + if (ci == NULL) /* no 'ci'? */ + return NULL; /* no info */ + else if (ci->callstatus & CIST_FIN) { /* is this a finalizer? */ + *name = "__gc"; + return "metamethod"; /* report it as such */ + } + /* calling function is a known Lua function? */ + else if (!(ci->callstatus & CIST_TAIL) && isLua(ci->previous)) + return funcnamefromcode(L, ci->previous, name); + else return NULL; /* no way to find a name */ +} + + static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar, Closure *f, CallInfo *ci) { int status = 1; @@ -242,11 +290,7 @@ static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar, break; } case 'n': { - /* calling function is a known Lua function? */ - if (ci && !(ci->callstatus & CIST_TAIL) && isLua(ci->previous)) - ar->namewhat = getfuncname(L, ci->previous, &ar->name); - else - ar->namewhat = NULL; + ar->namewhat = getfuncname(L, ci, &ar->name); if (ar->namewhat == NULL) { ar->namewhat = ""; /* not found */ ar->name = NULL; @@ -269,6 +313,7 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { CallInfo *ci; StkId func; lua_lock(L); + swapextra(L); if (*what == '>') { ci = NULL; func = L->top - 1; @@ -287,6 +332,7 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { setobjs2s(L, L->top, func); api_incr_top(L); } + swapextra(L); /* correct before option 'L', which can raise a mem. error */ if (strchr(what, 'L')) collectvalidlines(L, cl); lua_unlock(L); @@ -366,18 +412,13 @@ static int findsetreg (Proto *p, int lastpc, int reg) { case OP_JMP: { int b = GETARG_sBx(i); int dest = pc + 1 + b; - /* jump is forward and do not skip `lastpc'? */ + /* jump is forward and do not skip 'lastpc'? */ if (pc < dest && dest <= lastpc) { if (dest > jmptarget) jmptarget = dest; /* update 'jmptarget' */ } break; } - case OP_TEST: { - if (reg == a) /* jumped code can change 'a' */ - setreg = filterpc(pc, jmptarget); - break; - } default: if (testAMode(op) && reg == a) /* any instruction that set A */ setreg = filterpc(pc, jmptarget); @@ -442,39 +483,53 @@ static const char *getobjname (Proto *p, int lastpc, int reg, } -static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { - TMS tm; +/* +** Try to find a name for a function based on the code that called it. +** (Only works when function was called by a Lua function.) +** Returns what the name is (e.g., "for iterator", "method", +** "metamethod") and sets '*name' to point to the name. +*/ +static const char *funcnamefromcode (lua_State *L, CallInfo *ci, + const char **name) { + TMS tm = (TMS)0; /* (initial value avoids warnings) */ Proto *p = ci_func(ci)->p; /* calling function */ int pc = currentpc(ci); /* calling instruction index */ Instruction i = p->code[pc]; /* calling instruction */ + if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */ + *name = "?"; + return "hook"; + } switch (GET_OPCODE(i)) { case OP_CALL: - case OP_TAILCALL: /* get function name */ - return getobjname(p, pc, GETARG_A(i), name); + case OP_TAILCALL: + return getobjname(p, pc, GETARG_A(i), name); /* get function name */ case OP_TFORCALL: { /* for iterator */ *name = "for iterator"; return "for iterator"; } - /* all other instructions can call only through metamethods */ - case OP_SELF: - case OP_GETTABUP: - case OP_GETTABLE: tm = TM_INDEX; break; - case OP_SETTABUP: - case OP_SETTABLE: tm = TM_NEWINDEX; break; - case OP_EQ: tm = TM_EQ; break; - case OP_ADD: tm = TM_ADD; break; - case OP_SUB: tm = TM_SUB; break; - case OP_MUL: tm = TM_MUL; break; - case OP_DIV: tm = TM_DIV; break; - case OP_MOD: tm = TM_MOD; break; - case OP_POW: tm = TM_POW; break; + /* other instructions can do calls through metamethods */ + case OP_SELF: case OP_GETTABUP: case OP_GETTABLE: + tm = TM_INDEX; + break; + case OP_SETTABUP: case OP_SETTABLE: + tm = TM_NEWINDEX; + break; + case OP_ADD: case OP_SUB: case OP_MUL: case OP_MOD: + case OP_POW: case OP_DIV: case OP_IDIV: case OP_BAND: + case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR: { + int offset = cast_int(GET_OPCODE(i)) - cast_int(OP_ADD); /* ORDER OP */ + tm = cast(TMS, offset + cast_int(TM_ADD)); /* ORDER TM */ + break; + } case OP_UNM: tm = TM_UNM; break; + case OP_BNOT: tm = TM_BNOT; break; case OP_LEN: tm = TM_LEN; break; + case OP_CONCAT: tm = TM_CONCAT; break; + case OP_EQ: tm = TM_EQ; break; case OP_LT: tm = TM_LT; break; case OP_LE: tm = TM_LE; break; - case OP_CONCAT: tm = TM_CONCAT; break; default: - return NULL; /* else no useful name can be found */ + return NULL; /* cannot find a reasonable name */ } *name = getstr(G(L)->tmname[tm]); return "metamethod"; @@ -485,17 +540,21 @@ static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { /* -** only ANSI way to check whether a pointer points to an array -** (used only for error messages, so efficiency is not a big concern) +** The subtraction of two potentially unrelated pointers is +** not ISO C, but it should not crash a program; the subsequent +** checks are ISO C and ensure a correct result. */ static int isinstack (CallInfo *ci, const TValue *o) { - StkId p; - for (p = ci->u.l.base; p < ci->top; p++) - if (o == p) return 1; - return 0; + ptrdiff_t i = o - ci->u.l.base; + return (0 <= i && i < (ci->top - ci->u.l.base) && ci->u.l.base + i == o); } +/* +** Checks whether value 'o' came from an upvalue. (That can only happen +** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on +** upvalues.) +*/ static const char *getupvalname (CallInfo *ci, const TValue *o, const char **name) { LClosure *c = ci_func(ci); @@ -510,10 +569,9 @@ static const char *getupvalname (CallInfo *ci, const TValue *o, } -l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { +static const char *varinfo (lua_State *L, const TValue *o) { + const char *name = NULL; /* to avoid warnings */ CallInfo *ci = L->ci; - const char *name = NULL; - const char *t = objtypename(o); const char *kind = NULL; if (isLua(ci)) { kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */ @@ -521,73 +579,122 @@ l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { kind = getobjname(ci_func(ci)->p, currentpc(ci), cast_int(o - ci->u.l.base), &name); } - if (kind) - luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)", - op, kind, name, t); - else - luaG_runerror(L, "attempt to %s a %s value", op, t); + return (kind) ? luaO_pushfstring(L, " (%s '%s')", kind, name) : ""; } -l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2) { - if (ttisstring(p1) || ttisnumber(p1)) p1 = p2; - lua_assert(!ttisstring(p1) && !ttisnumber(p1)); +l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { + const char *t = luaT_objtypename(L, o); + luaG_runerror(L, "attempt to %s a %s value%s", op, t, varinfo(L, o)); +} + + +l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) { + if (ttisstring(p1) || cvt2str(p1)) p1 = p2; luaG_typeerror(L, p1, "concatenate"); } -l_noret luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) { - TValue temp; - if (luaV_tonumber(p1, &temp) == NULL) - p2 = p1; /* first operand is wrong */ - luaG_typeerror(L, p2, "perform arithmetic on"); +l_noret luaG_opinterror (lua_State *L, const TValue *p1, + const TValue *p2, const char *msg) { + lua_Number temp; + if (!tonumber(p1, &temp)) /* first operand is wrong? */ + p2 = p1; /* now second is wrong */ + luaG_typeerror(L, p2, msg); +} + + +/* +** Error when both values are convertible to numbers, but not to integers +*/ +l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) { + lua_Integer temp; + if (!tointeger(p1, &temp)) + p2 = p1; + luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2)); } l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { - const char *t1 = objtypename(p1); - const char *t2 = objtypename(p2); - if (t1 == t2) + const char *t1 = luaT_objtypename(L, p1); + const char *t2 = luaT_objtypename(L, p2); + if (strcmp(t1, t2) == 0) luaG_runerror(L, "attempt to compare two %s values", t1); else luaG_runerror(L, "attempt to compare %s with %s", t1, t2); } -static void addinfo (lua_State *L, const char *msg) { - CallInfo *ci = L->ci; - if (isLua(ci)) { /* is Lua code? */ - char buff[LUA_IDSIZE]; /* add file:line information */ - int line = currentline(ci); - TString *src = ci_func(ci)->p->source; - if (src) - luaO_chunkid(buff, getstr(src), LUA_IDSIZE); - else { /* no source available; use "?" instead */ - buff[0] = '?'; buff[1] = '\0'; - } - luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); +/* add src:line information to 'msg' */ +const char *luaG_addinfo (lua_State *L, const char *msg, TString *src, + int line) { + char buff[LUA_IDSIZE]; + if (src) + luaO_chunkid(buff, getstr(src), LUA_IDSIZE); + else { /* no source available; use "?" instead */ + buff[0] = '?'; buff[1] = '\0'; } + return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); } l_noret luaG_errormsg (lua_State *L) { if (L->errfunc != 0) { /* is there an error handling function? */ StkId errfunc = restorestack(L, L->errfunc); - if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR); setobjs2s(L, L->top, L->top - 1); /* move argument */ setobjs2s(L, L->top - 1, errfunc); /* push function */ - L->top++; - luaD_call(L, L->top - 2, 1, 0); /* call it */ + L->top++; /* assume EXTRA_STACK */ + luaD_callnoyield(L, L->top - 2, 1); /* call it */ } luaD_throw(L, LUA_ERRRUN); } l_noret luaG_runerror (lua_State *L, const char *fmt, ...) { + CallInfo *ci = L->ci; + const char *msg; va_list argp; + luaC_checkGC(L); /* error message uses memory */ va_start(argp, fmt); - addinfo(L, luaO_pushvfstring(L, fmt, argp)); + msg = luaO_pushvfstring(L, fmt, argp); /* format message */ va_end(argp); + if (isLua(ci)) /* if Lua function, add source:line information */ + luaG_addinfo(L, msg, ci_func(ci)->p->source, currentline(ci)); luaG_errormsg(L); } + +void luaG_traceexec (lua_State *L) { + CallInfo *ci = L->ci; + lu_byte mask = L->hookmask; + int counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT)); + if (counthook) + resethookcount(L); /* reset count */ + else if (!(mask & LUA_MASKLINE)) + return; /* no line hook and count != 0; nothing to be done */ + if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */ + ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ + return; /* do not call hook again (VM yielded, so it did not move) */ + } + if (counthook) + luaD_hook(L, LUA_HOOKCOUNT, -1); /* call count hook */ + if (mask & LUA_MASKLINE) { + Proto *p = ci_func(ci)->p; + int npc = pcRel(ci->u.l.savedpc, p); + int newline = getfuncline(p, npc); + if (npc == 0 || /* call linehook when enter a new function, */ + ci->u.l.savedpc <= L->oldpc || /* when jump back (loop), or when */ + newline != getfuncline(p, pcRel(L->oldpc, p))) /* enter a new line */ + luaD_hook(L, LUA_HOOKLINE, newline); /* call line hook */ + } + L->oldpc = ci->u.l.savedpc; + if (L->status == LUA_YIELD) { /* did hook yield? */ + if (counthook) + L->hookcount = 1; /* undo decrement to zero */ + ci->u.l.savedpc--; /* undo increment (resume will increment it again) */ + ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ + ci->func = L->top - 1; /* protect stack below results */ + luaD_throw(L, LUA_YIELD); + } +} + diff --git a/depends/lua/src/ldo.c b/depends/lua/src/ldo.c index e9dd5fa951..65158df0b7 100644 --- a/depends/lua/src/ldo.c +++ b/depends/lua/src/ldo.c @@ -1,17 +1,19 @@ /* -** $Id: ldo.c,v 2.108.1.3 2013/11/08 18:22:50 roberto Exp $ +** $Id: ldo.c,v 2.157.1.1 2017/04/19 17:20:42 roberto Exp $ ** Stack and Call structure of Lua ** See Copyright Notice in lua.h */ +#define ldo_c +#define LUA_CORE + +#include "lprefix.h" + #include #include #include -#define ldo_c -#define LUA_CORE - #include "lua.h" #include "lapi.h" @@ -33,6 +35,8 @@ +#define errorstatus(s) ((s) > LUA_YIELD) + /* ** {====================================================== @@ -46,30 +50,33 @@ ** C++ code, with _longjmp/_setjmp when asked to use them, and with ** longjmp/setjmp otherwise. */ -#if !defined(LUAI_THROW) +#if !defined(LUAI_THROW) /* { */ + +#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) /* { */ -#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) /* C++ exceptions */ #define LUAI_THROW(L,c) throw(c) #define LUAI_TRY(L,c,a) \ try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; } #define luai_jmpbuf int /* dummy variable */ -#elif defined(LUA_USE_ULONGJMP) -/* in Unix, try _longjmp/_setjmp (more efficient) */ +#elif defined(LUA_USE_POSIX) /* }{ */ + +/* in POSIX, try _longjmp/_setjmp (more efficient) */ #define LUAI_THROW(L,c) _longjmp((c)->b, 1) #define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } #define luai_jmpbuf jmp_buf -#else -/* default handling with long jumps */ +#else /* }{ */ + +/* ISO C handling with long jumps */ #define LUAI_THROW(L,c) longjmp((c)->b, 1) #define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } #define luai_jmpbuf jmp_buf -#endif +#endif /* } */ -#endif +#endif /* } */ @@ -106,15 +113,19 @@ l_noret luaD_throw (lua_State *L, int errcode) { LUAI_THROW(L, L->errorJmp); /* jump to it */ } else { /* thread has no error handler */ + global_State *g = G(L); L->status = cast_byte(errcode); /* mark it as dead */ - if (G(L)->mainthread->errorJmp) { /* main thread has a handler? */ - setobjs2s(L, G(L)->mainthread->top++, L->top - 1); /* copy error obj. */ - luaD_throw(G(L)->mainthread, errcode); /* re-throw in main thread */ + if (g->mainthread->errorJmp) { /* main thread has a handler? */ + setobjs2s(L, g->mainthread->top++, L->top - 1); /* copy error obj. */ + luaD_throw(g->mainthread, errcode); /* re-throw in main thread */ } else { /* no handler at all; abort */ - if (G(L)->panic) { /* panic function? */ + if (g->panic) { /* panic function? */ + seterrorobj(L, errcode, L->top); /* assume EXTRA_STACK */ + if (L->ci->top < L->top) + L->ci->top = L->top; /* pushing msg. can break this invariant */ lua_unlock(L); - G(L)->panic(L); /* call it (last chance to jump out) */ + g->panic(L); /* call panic function (last chance to jump out) */ } abort(); } @@ -139,12 +150,17 @@ int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { /* }====================================================== */ +/* +** {================================================================== +** Stack reallocation +** =================================================================== +*/ static void correctstack (lua_State *L, TValue *oldstack) { CallInfo *ci; - GCObject *up; + UpVal *up; L->top = (L->top - oldstack) + L->stack; - for (up = L->openupval; up != NULL; up = up->gch.next) - gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack; + for (up = L->openupval; up != NULL; up = up->u.open.next) + up->v = (up->v - oldstack) + L->stack; for (ci = L->ci; ci != NULL; ci = ci->previous) { ci->top = (ci->top - oldstack) + L->stack; ci->func = (ci->func - oldstack) + L->stack; @@ -195,9 +211,9 @@ static int stackinuse (lua_State *L) { CallInfo *ci; StkId lim = L->top; for (ci = L->ci; ci != NULL; ci = ci->previous) { - lua_assert(ci->top <= L->stack_last); if (lim < ci->top) lim = ci->top; } + lua_assert(lim <= L->stack_last); return cast_int(lim - L->stack) + 1; /* part of stack in use */ } @@ -205,18 +221,38 @@ static int stackinuse (lua_State *L) { void luaD_shrinkstack (lua_State *L) { int inuse = stackinuse(L); int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK; - if (goodsize > LUAI_MAXSTACK) goodsize = LUAI_MAXSTACK; - if (inuse > LUAI_MAXSTACK || /* handling stack overflow? */ - goodsize >= L->stacksize) /* would grow instead of shrink? */ - condmovestack(L); /* don't change stack (change only for debugging) */ + if (goodsize > LUAI_MAXSTACK) + goodsize = LUAI_MAXSTACK; /* respect stack limit */ + if (L->stacksize > LUAI_MAXSTACK) /* had been handling stack overflow? */ + luaE_freeCI(L); /* free all CIs (list grew because of an error) */ else - luaD_reallocstack(L, goodsize); /* shrink it */ + luaE_shrinkCI(L); /* shrink list */ + /* if thread is currently not handling a stack overflow and its + good size is smaller than current size, shrink its stack */ + if (inuse <= (LUAI_MAXSTACK - EXTRA_STACK) && + goodsize < L->stacksize) + luaD_reallocstack(L, goodsize); + else /* don't change stack */ + condmovestack(L,{},{}); /* (change only for debugging) */ } +void luaD_inctop (lua_State *L) { + luaD_checkstack(L, 1); + L->top++; +} + +/* }================================================================== */ + + +/* +** Call a hook for the given event. Make sure there is a hook to be +** called. (Both 'L->hook' and 'L->hookmask', which triggers this +** function, can be changed asynchronously by signals.) +*/ void luaD_hook (lua_State *L, int event, int line) { lua_Hook hook = L->hook; - if (hook && L->allowhook) { + if (hook && L->allowhook) { /* make sure there is a hook */ CallInfo *ci = L->ci; ptrdiff_t top = savestack(L, L->top); ptrdiff_t ci_top = savestack(L, ci->top); @@ -258,31 +294,100 @@ static StkId adjust_varargs (lua_State *L, Proto *p, int actual) { int i; int nfixargs = p->numparams; StkId base, fixed; - lua_assert(actual >= nfixargs); /* move fixed parameters to final position */ - luaD_checkstack(L, p->maxstacksize); /* check again for new 'base' */ fixed = L->top - actual; /* first fixed argument */ base = L->top; /* final position of first argument */ - for (i=0; itop++, fixed + i); - setnilvalue(fixed + i); + setnilvalue(fixed + i); /* erase original copy (for GC) */ } + for (; i < nfixargs; i++) + setnilvalue(L->top++); /* complete missing arguments */ return base; } -static StkId tryfuncTM (lua_State *L, StkId func) { +/* +** Check whether __call metafield of 'func' is a function. If so, put +** it in stack below original 'func' so that 'luaD_precall' can call +** it. Raise an error if __call metafield is not a function. +*/ +static void tryfuncTM (lua_State *L, StkId func) { const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL); StkId p; - ptrdiff_t funcr = savestack(L, func); if (!ttisfunction(tm)) luaG_typeerror(L, func, "call"); - /* Open a hole inside the stack at `func' */ - for (p = L->top; p > func; p--) setobjs2s(L, p, p-1); - incr_top(L); - func = restorestack(L, funcr); /* previous call may change stack */ + /* Open a hole inside the stack at 'func' */ + for (p = L->top; p > func; p--) + setobjs2s(L, p, p-1); + L->top++; /* slot ensured by caller */ setobj2s(L, func, tm); /* tag method is the new function to be called */ - return func; +} + + +/* +** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'. +** Handle most typical cases (zero results for commands, one result for +** expressions, multiple results for tail calls/single parameters) +** separated. +*/ +static int moveresults (lua_State *L, const TValue *firstResult, StkId res, + int nres, int wanted) { + switch (wanted) { /* handle typical cases separately */ + case 0: break; /* nothing to move */ + case 1: { /* one result needed */ + if (nres == 0) /* no results? */ + firstResult = luaO_nilobject; /* adjust with nil */ + setobjs2s(L, res, firstResult); /* move it to proper place */ + break; + } + case LUA_MULTRET: { + int i; + for (i = 0; i < nres; i++) /* move all results to correct place */ + setobjs2s(L, res + i, firstResult + i); + L->top = res + nres; + return 0; /* wanted == LUA_MULTRET */ + } + default: { + int i; + if (wanted <= nres) { /* enough results? */ + for (i = 0; i < wanted; i++) /* move wanted results to correct place */ + setobjs2s(L, res + i, firstResult + i); + } + else { /* not enough results; use all of them plus nils */ + for (i = 0; i < nres; i++) /* move all results to correct place */ + setobjs2s(L, res + i, firstResult + i); + for (; i < wanted; i++) /* complete wanted number of results */ + setnilvalue(res + i); + } + break; + } + } + L->top = res + wanted; /* top points after the last result */ + return 1; +} + + +/* +** Finishes a function call: calls hook if necessary, removes CallInfo, +** moves current number of results to proper place; returns 0 iff call +** wanted multiple (variable number of) results. +*/ +int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) { + StkId res; + int wanted = ci->nresults; + if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) { + if (L->hookmask & LUA_MASKRET) { + ptrdiff_t fr = savestack(L, firstResult); /* hook may change stack */ + luaD_hook(L, LUA_HOOKRET, -1); + firstResult = restorestack(L, fr); + } + L->oldpc = ci->previous->u.l.savedpc; /* 'oldpc' for caller function */ + } + res = ci->func; /* res == final position of 1st result */ + L->ci = ci->previous; /* back to caller */ + /* move results to proper place */ + return moveresults(L, firstResult, res, nres, wanted); } @@ -290,97 +395,94 @@ static StkId tryfuncTM (lua_State *L, StkId func) { #define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L))) +/* macro to check stack size, preserving 'p' */ +#define checkstackp(L,n,p) \ + luaD_checkstackaux(L, n, \ + ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ + luaC_checkGC(L), /* stack grow uses memory */ \ + p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ + + /* -** returns true if function has been executed (C function) +** Prepares a function call: checks the stack, creates a new CallInfo +** entry, fills in the relevant information, calls hook if needed. +** If function is a C function, does the call, too. (Otherwise, leave +** the execution ('luaV_execute') to the caller, to allow stackless +** calls.) Returns true iff function has been executed (C function). */ int luaD_precall (lua_State *L, StkId func, int nresults) { lua_CFunction f; CallInfo *ci; - int n; /* number of arguments (Lua) or returns (C) */ - ptrdiff_t funcr = savestack(L, func); switch (ttype(func)) { + case LUA_TCCL: /* C closure */ + f = clCvalue(func)->f; + goto Cfunc; case LUA_TLCF: /* light C function */ f = fvalue(func); - goto Cfunc; - case LUA_TCCL: { /* C closure */ - f = clCvalue(func)->f; - Cfunc: - luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ + Cfunc: { + int n; /* number of returns */ + checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */ ci = next_ci(L); /* now 'enter' new function */ ci->nresults = nresults; - ci->func = restorestack(L, funcr); + ci->func = func; ci->top = L->top + LUA_MINSTACK; lua_assert(ci->top <= L->stack_last); ci->callstatus = 0; - luaC_checkGC(L); /* stack grow uses memory */ if (L->hookmask & LUA_MASKCALL) luaD_hook(L, LUA_HOOKCALL, -1); lua_unlock(L); n = (*f)(L); /* do the actual call */ lua_lock(L); api_checknelems(L, n); - luaD_poscall(L, L->top - n); + luaD_poscall(L, ci, L->top - n, n); return 1; } case LUA_TLCL: { /* Lua function: prepare its call */ StkId base; Proto *p = clLvalue(func)->p; - n = cast_int(L->top - func) - 1; /* number of real arguments */ - luaD_checkstack(L, p->maxstacksize); - for (; n < p->numparams; n++) - setnilvalue(L->top++); /* complete missing arguments */ - if (!p->is_vararg) { - func = restorestack(L, funcr); - base = func + 1; - } - else { + int n = cast_int(L->top - func) - 1; /* number of real arguments */ + int fsize = p->maxstacksize; /* frame size */ + checkstackp(L, fsize, func); + if (p->is_vararg) base = adjust_varargs(L, p, n); - func = restorestack(L, funcr); /* previous call can change stack */ + else { /* non vararg function */ + for (; n < p->numparams; n++) + setnilvalue(L->top++); /* complete missing arguments */ + base = func + 1; } ci = next_ci(L); /* now 'enter' new function */ ci->nresults = nresults; ci->func = func; ci->u.l.base = base; - ci->top = base + p->maxstacksize; + L->top = ci->top = base + fsize; lua_assert(ci->top <= L->stack_last); ci->u.l.savedpc = p->code; /* starting point */ ci->callstatus = CIST_LUA; - L->top = ci->top; - luaC_checkGC(L); /* stack grow uses memory */ if (L->hookmask & LUA_MASKCALL) callhook(L, ci); return 0; } default: { /* not a function */ - func = tryfuncTM(L, func); /* retry with 'function' tag method */ + checkstackp(L, 1, func); /* ensure space for metamethod */ + tryfuncTM(L, func); /* try to get '__call' metamethod */ return luaD_precall(L, func, nresults); /* now it must be a function */ } } } -int luaD_poscall (lua_State *L, StkId firstResult) { - StkId res; - int wanted, i; - CallInfo *ci = L->ci; - if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) { - if (L->hookmask & LUA_MASKRET) { - ptrdiff_t fr = savestack(L, firstResult); /* hook may change stack */ - luaD_hook(L, LUA_HOOKRET, -1); - firstResult = restorestack(L, fr); - } - L->oldpc = ci->previous->u.l.savedpc; /* 'oldpc' for caller function */ - } - res = ci->func; /* res == final position of 1st result */ - wanted = ci->nresults; - L->ci = ci = ci->previous; /* back to caller */ - /* move results to correct place */ - for (i = wanted; i != 0 && firstResult < L->top; i--) - setobjs2s(L, res++, firstResult++); - while (i-- > 0) - setnilvalue(res++); - L->top = res; - return (wanted - LUA_MULTRET); /* 0 iff wanted == LUA_MULTRET */ +/* +** Check appropriate error for stack overflow ("regular" overflow or +** overflow while handling stack overflow). If 'nCalls' is larger than +** LUAI_MAXCCALLS (which means it is handling a "regular" overflow) but +** smaller than 9/8 of LUAI_MAXCCALLS, does not report an error (to +** allow overflow handling to work) +*/ +static void stackerror (lua_State *L) { + if (L->nCcalls == LUAI_MAXCCALLS) + luaG_runerror(L, "C stack overflow"); + else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3))) + luaD_throw(L, LUA_ERRERR); /* error while handing stack error */ } @@ -390,53 +492,65 @@ int luaD_poscall (lua_State *L, StkId firstResult) { ** When returns, all the results are on the stack, starting at the original ** function position. */ -void luaD_call (lua_State *L, StkId func, int nResults, int allowyield) { - if (++L->nCcalls >= LUAI_MAXCCALLS) { - if (L->nCcalls == LUAI_MAXCCALLS) - luaG_runerror(L, "C stack overflow"); - else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3))) - luaD_throw(L, LUA_ERRERR); /* error while handing stack error */ - } - if (!allowyield) L->nny++; +void luaD_call (lua_State *L, StkId func, int nResults) { + if (++L->nCcalls >= LUAI_MAXCCALLS) + stackerror(L); if (!luaD_precall(L, func, nResults)) /* is a Lua function? */ luaV_execute(L); /* call it */ - if (!allowyield) L->nny--; L->nCcalls--; } -static void finishCcall (lua_State *L) { +/* +** Similar to 'luaD_call', but does not allow yields during the call +*/ +void luaD_callnoyield (lua_State *L, StkId func, int nResults) { + L->nny++; + luaD_call(L, func, nResults); + L->nny--; +} + + +/* +** Completes the execution of an interrupted C function, calling its +** continuation function. +*/ +static void finishCcall (lua_State *L, int status) { CallInfo *ci = L->ci; int n; - lua_assert(ci->u.c.k != NULL); /* must have a continuation */ - lua_assert(L->nny == 0); + /* must have a continuation and must be able to call it */ + lua_assert(ci->u.c.k != NULL && L->nny == 0); + /* error status can only happen in a protected call */ + lua_assert((ci->callstatus & CIST_YPCALL) || status == LUA_YIELD); if (ci->callstatus & CIST_YPCALL) { /* was inside a pcall? */ - ci->callstatus &= ~CIST_YPCALL; /* finish 'lua_pcall' */ - L->errfunc = ci->u.c.old_errfunc; + ci->callstatus &= ~CIST_YPCALL; /* continuation is also inside it */ + L->errfunc = ci->u.c.old_errfunc; /* with the same error function */ } - /* finish 'lua_callk'/'lua_pcall' */ + /* finish 'lua_callk'/'lua_pcall'; CIST_YPCALL and 'errfunc' already + handled */ adjustresults(L, ci->nresults); - /* call continuation function */ - if (!(ci->callstatus & CIST_STAT)) /* no call status? */ - ci->u.c.status = LUA_YIELD; /* 'default' status */ - lua_assert(ci->u.c.status != LUA_OK); - ci->callstatus = (ci->callstatus & ~(CIST_YPCALL | CIST_STAT)) | CIST_YIELDED; lua_unlock(L); - n = (*ci->u.c.k)(L); + n = (*ci->u.c.k)(L, status, ci->u.c.ctx); /* call continuation function */ lua_lock(L); api_checknelems(L, n); - /* finish 'luaD_precall' */ - luaD_poscall(L, L->top - n); + luaD_poscall(L, ci, L->top - n, n); /* finish 'luaD_precall' */ } +/* +** Executes "full continuation" (everything in the stack) of a +** previously interrupted coroutine until the stack is empty (or another +** interruption long-jumps out of the loop). If the coroutine is +** recovering from an error, 'ud' points to the error status, which must +** be passed to the first continuation function (otherwise the default +** status is LUA_YIELD). +*/ static void unroll (lua_State *L, void *ud) { - UNUSED(ud); - for (;;) { - if (L->ci == &L->base_ci) /* stack is empty? */ - return; /* coroutine finished normally */ + if (ud != NULL) /* error status? */ + finishCcall(L, *(int *)ud); /* finish 'lua_pcallk' callee */ + while (L->ci != &L->base_ci) { /* something in the stack */ if (!isLua(L->ci)) /* C function? */ - finishCcall(L); + finishCcall(L, LUA_YIELD); /* complete its execution */ else { /* Lua function */ luaV_finishOp(L); /* finish interrupted instruction */ luaV_execute(L); /* execute down to higher C 'boundary' */ @@ -446,7 +560,8 @@ static void unroll (lua_State *L, void *ud) { /* -** check whether thread has a suspended protected call +** Try to find a suspended protected call (a "recover point") for the +** given thread. */ static CallInfo *findpcall (lua_State *L) { CallInfo *ci; @@ -458,6 +573,11 @@ static CallInfo *findpcall (lua_State *L) { } +/* +** Recovers from an error in a coroutine. Finds a recover point (if +** there is one) and completes the execution of the interrupted +** 'luaD_pcall'. If there is no recover point, returns zero. +*/ static int recover (lua_State *L, int status) { StkId oldtop; CallInfo *ci = findpcall(L); @@ -467,94 +587,94 @@ static int recover (lua_State *L, int status) { luaF_close(L, oldtop); seterrorobj(L, status, oldtop); L->ci = ci; - L->allowhook = ci->u.c.old_allowhook; + L->allowhook = getoah(ci->callstatus); /* restore original 'allowhook' */ L->nny = 0; /* should be zero to be yieldable */ luaD_shrinkstack(L); L->errfunc = ci->u.c.old_errfunc; - ci->callstatus |= CIST_STAT; /* call has error status */ - ci->u.c.status = status; /* (here it is) */ return 1; /* continue running the coroutine */ } /* -** signal an error in the call to 'resume', not in the execution of the -** coroutine itself. (Such errors should not be handled by any coroutine -** error handler and should not kill the coroutine.) +** Signal an error in the call to 'lua_resume', not in the execution +** of the coroutine itself. (Such errors should not be handled by any +** coroutine error handler and should not kill the coroutine.) */ -static l_noret resume_error (lua_State *L, const char *msg, StkId firstArg) { - L->top = firstArg; /* remove args from the stack */ +static int resume_error (lua_State *L, const char *msg, int narg) { + L->top -= narg; /* remove args from the stack */ setsvalue2s(L, L->top, luaS_new(L, msg)); /* push error message */ api_incr_top(L); - luaD_throw(L, -1); /* jump back to 'lua_resume' */ + lua_unlock(L); + return LUA_ERRRUN; } /* -** do the work for 'lua_resume' in protected mode +** Do the work for 'lua_resume' in protected mode. Most of the work +** depends on the status of the coroutine: initial state, suspended +** inside a hook, or regularly suspended (optionally with a continuation +** function), plus erroneous cases: non-suspended coroutine or dead +** coroutine. */ static void resume (lua_State *L, void *ud) { - int nCcalls = L->nCcalls; - StkId firstArg = cast(StkId, ud); + int n = *(cast(int*, ud)); /* number of arguments */ + StkId firstArg = L->top - n; /* first argument */ CallInfo *ci = L->ci; - if (nCcalls >= LUAI_MAXCCALLS) - resume_error(L, "C stack overflow", firstArg); - if (L->status == LUA_OK) { /* may be starting a coroutine */ - if (ci != &L->base_ci) /* not in base level? */ - resume_error(L, "cannot resume non-suspended coroutine", firstArg); - /* coroutine is in base level; start running it */ + if (L->status == LUA_OK) { /* starting a coroutine? */ if (!luaD_precall(L, firstArg - 1, LUA_MULTRET)) /* Lua function? */ luaV_execute(L); /* call it */ } - else if (L->status != LUA_YIELD) - resume_error(L, "cannot resume dead coroutine", firstArg); else { /* resuming from previous yield */ - L->status = LUA_OK; + lua_assert(L->status == LUA_YIELD); + L->status = LUA_OK; /* mark that it is running (again) */ ci->func = restorestack(L, ci->extra); if (isLua(ci)) /* yielded inside a hook? */ luaV_execute(L); /* just continue running Lua code */ else { /* 'common' yield */ - if (ci->u.c.k != NULL) { /* does it have a continuation? */ - int n; - ci->u.c.status = LUA_YIELD; /* 'default' status */ - ci->callstatus |= CIST_YIELDED; + if (ci->u.c.k != NULL) { /* does it have a continuation function? */ lua_unlock(L); - n = (*ci->u.c.k)(L); /* call continuation */ + n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */ lua_lock(L); api_checknelems(L, n); firstArg = L->top - n; /* yield results come from continuation */ } - luaD_poscall(L, firstArg); /* finish 'luaD_precall' */ + luaD_poscall(L, ci, firstArg, n); /* finish 'luaD_precall' */ } - unroll(L, NULL); + unroll(L, NULL); /* run continuation */ } - lua_assert(nCcalls == L->nCcalls); } LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) { int status; - int oldnny = L->nny; /* save 'nny' */ + unsigned short oldnny = L->nny; /* save "number of non-yieldable" calls */ lua_lock(L); - luai_userstateresume(L, nargs); + if (L->status == LUA_OK) { /* may be starting a coroutine */ + if (L->ci != &L->base_ci) /* not in base level? */ + return resume_error(L, "cannot resume non-suspended coroutine", nargs); + } + else if (L->status != LUA_YIELD) + return resume_error(L, "cannot resume dead coroutine", nargs); L->nCcalls = (from) ? from->nCcalls + 1 : 1; + if (L->nCcalls >= LUAI_MAXCCALLS) + return resume_error(L, "C stack overflow", nargs); + luai_userstateresume(L, nargs); L->nny = 0; /* allow yields */ api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs); - status = luaD_rawrunprotected(L, resume, L->top - nargs); + status = luaD_rawrunprotected(L, resume, &nargs); if (status == -1) /* error calling 'lua_resume'? */ status = LUA_ERRRUN; - else { /* yield or regular error */ - while (status != LUA_OK && status != LUA_YIELD) { /* error? */ - if (recover(L, status)) /* recover point? */ - status = luaD_rawrunprotected(L, unroll, NULL); /* run continuation */ - else { /* unrecoverable error */ - L->status = cast_byte(status); /* mark thread as `dead' */ - seterrorobj(L, status, L->top); - L->ci->top = L->top; - break; - } + else { /* continue running after recoverable errors */ + while (errorstatus(status) && recover(L, status)) { + /* unroll continuation */ + status = luaD_rawrunprotected(L, unroll, &status); } - lua_assert(status == L->status); + if (errorstatus(status)) { /* unrecoverable error? */ + L->status = cast_byte(status); /* mark thread as 'dead' */ + seterrorobj(L, status, L->top); /* push error message */ + L->ci->top = L->top; + } + else lua_assert(status == L->status); /* normal end or yield */ } L->nny = oldnny; /* restore 'nny' */ L->nCcalls--; @@ -564,7 +684,13 @@ LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) { } -LUA_API int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k) { +LUA_API int lua_isyieldable (lua_State *L) { + return (L->nny == 0); +} + + +LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx, + lua_KFunction k) { CallInfo *ci = L->ci; luai_userstateyield(L, nresults); lua_lock(L); @@ -619,7 +745,7 @@ int luaD_pcall (lua_State *L, Pfunc func, void *u, /* ** Execute a protected parser. */ -struct SParser { /* data to `f_parser' */ +struct SParser { /* data to 'f_parser' */ ZIO *z; Mbuffer buff; /* dynamic structure used by the scanner */ Dyndata dyd; /* dynamic structures used by the parser */ @@ -631,31 +757,26 @@ struct SParser { /* data to `f_parser' */ static void checkmode (lua_State *L, const char *mode, const char *x) { if (mode && strchr(mode, x[0]) == NULL) { luaO_pushfstring(L, - "attempt to load a %s chunk (mode is " LUA_QS ")", x, mode); + "attempt to load a %s chunk (mode is '%s')", x, mode); luaD_throw(L, LUA_ERRSYNTAX); } } static void f_parser (lua_State *L, void *ud) { - int i; - Closure *cl; + LClosure *cl; struct SParser *p = cast(struct SParser *, ud); int c = zgetc(p->z); /* read first character */ - if (c == LUA_SIGNATURE[0]) { - checkmode(L, p->mode, "binary"); - cl = luaU_undump(L, p->z, &p->buff, p->name); - } - else { + // if (c == LUA_SIGNATURE[0]) { + // checkmode(L, p->mode, "binary"); + // cl = luaU_undump(L, p->z, p->name); + // } + // else { checkmode(L, p->mode, "text"); cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c); - } - lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues); - for (i = 0; i < cl->l.nupvalues; i++) { /* initialize upvalues */ - UpVal *up = luaF_newupval(L); - cl->l.upvals[i] = up; - luaC_objbarrier(L, cl, up); - } + // } + lua_assert(cl->nupvalues == cl->p->sizeupvalues); + luaF_initupvals(L, cl); } diff --git a/depends/lua/src/ldump.c b/depends/lua/src/ldump.c index 61fa2cd892..f025acac3c 100644 --- a/depends/lua/src/ldump.c +++ b/depends/lua/src/ldump.c @@ -1,173 +1,215 @@ /* -** $Id: ldump.c,v 2.17.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: ldump.c,v 2.37.1.1 2017/04/19 17:20:42 roberto Exp $ ** save precompiled Lua chunks ** See Copyright Notice in lua.h */ -#include - #define ldump_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" #include "lobject.h" #include "lstate.h" #include "lundump.h" + typedef struct { - lua_State* L; - lua_Writer writer; - void* data; - int strip; - int status; + lua_State *L; + lua_Writer writer; + void *data; + int strip; + int status; } DumpState; -#define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D) -#define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D) - -static void DumpBlock(const void* b, size_t size, DumpState* D) -{ - if (D->status==0) - { - lua_unlock(D->L); - D->status=(*D->writer)(D->L,b,size,D->data); - lua_lock(D->L); - } + +/* +** All high-level dumps go through DumpVector; you can change it to +** change the endianness of the result +*/ +#define DumpVector(v,n,D) DumpBlock(v,(n)*sizeof((v)[0]),D) + +#define DumpLiteral(s,D) DumpBlock(s, sizeof(s) - sizeof(char), D) + + +static void DumpBlock (const void *b, size_t size, DumpState *D) { + if (D->status == 0 && size > 0) { + lua_unlock(D->L); + D->status = (*D->writer)(D->L, b, size, D->data); + lua_lock(D->L); + } } -static void DumpChar(int y, DumpState* D) -{ - char x=(char)y; - DumpVar(x,D); + +#define DumpVar(x,D) DumpVector(&x,1,D) + + +static void DumpByte (int y, DumpState *D) { + lu_byte x = (lu_byte)y; + DumpVar(x, D); } -static void DumpInt(int x, DumpState* D) -{ - DumpVar(x,D); + +static void DumpInt (int x, DumpState *D) { + DumpVar(x, D); } -static void DumpNumber(lua_Number x, DumpState* D) -{ - DumpVar(x,D); + +static void DumpNumber (lua_Number x, DumpState *D) { + DumpVar(x, D); } -static void DumpVector(const void* b, int n, size_t size, DumpState* D) -{ - DumpInt(n,D); - DumpMem(b,n,size,D); + +static void DumpInteger (lua_Integer x, DumpState *D) { + DumpVar(x, D); } -static void DumpString(const TString* s, DumpState* D) -{ - if (s==NULL) - { - size_t size=0; - DumpVar(size,D); - } - else - { - size_t size=s->tsv.len+1; /* include trailing '\0' */ - DumpVar(size,D); - DumpBlock(getstr(s),size*sizeof(char),D); - } + +static void DumpString (const TString *s, DumpState *D) { + if (s == NULL) + DumpByte(0, D); + else { + size_t size = tsslen(s) + 1; /* include trailing '\0' */ + const char *str = getstr(s); + if (size < 0xFF) + DumpByte(cast_int(size), D); + else { + DumpByte(0xFF, D); + DumpVar(size, D); + } + DumpVector(str, size - 1, D); /* no need to save '\0' */ + } } -#define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D) - -static void DumpFunction(const Proto* f, DumpState* D); - -static void DumpConstants(const Proto* f, DumpState* D) -{ - int i,n=f->sizek; - DumpInt(n,D); - for (i=0; ik[i]; - DumpChar(ttypenv(o),D); - switch (ttypenv(o)) - { - case LUA_TNIL: - break; - case LUA_TBOOLEAN: - DumpChar(bvalue(o),D); - break; - case LUA_TNUMBER: - DumpNumber(nvalue(o),D); - break; - case LUA_TSTRING: - DumpString(rawtsvalue(o),D); - break; - default: lua_assert(0); + +static void DumpCode (const Proto *f, DumpState *D) { + DumpInt(f->sizecode, D); + DumpVector(f->code, f->sizecode, D); +} + + +static void DumpFunction(const Proto *f, TString *psource, DumpState *D); + +static void DumpConstants (const Proto *f, DumpState *D) { + int i; + int n = f->sizek; + DumpInt(n, D); + for (i = 0; i < n; i++) { + const TValue *o = &f->k[i]; + DumpByte(ttype(o), D); + switch (ttype(o)) { + case LUA_TNIL: + break; + case LUA_TBOOLEAN: + DumpByte(bvalue(o), D); + break; + case LUA_TNUMFLT: + DumpNumber(fltvalue(o), D); + break; + case LUA_TNUMINT: + DumpInteger(ivalue(o), D); + break; + case LUA_TSHRSTR: + case LUA_TLNGSTR: + DumpString(tsvalue(o), D); + break; + default: + lua_assert(0); + } } - } - n=f->sizep; - DumpInt(n,D); - for (i=0; ip[i],D); } -static void DumpUpvalues(const Proto* f, DumpState* D) -{ - int i,n=f->sizeupvalues; - DumpInt(n,D); - for (i=0; iupvalues[i].instack,D); - DumpChar(f->upvalues[i].idx,D); - } + +static void DumpProtos (const Proto *f, DumpState *D) { + int i; + int n = f->sizep; + DumpInt(n, D); + for (i = 0; i < n; i++) + DumpFunction(f->p[i], f->source, D); +} + + +static void DumpUpvalues (const Proto *f, DumpState *D) { + int i, n = f->sizeupvalues; + DumpInt(n, D); + for (i = 0; i < n; i++) { + DumpByte(f->upvalues[i].instack, D); + DumpByte(f->upvalues[i].idx, D); + } } -static void DumpDebug(const Proto* f, DumpState* D) -{ - int i,n; - DumpString((D->strip) ? NULL : f->source,D); - n= (D->strip) ? 0 : f->sizelineinfo; - DumpVector(f->lineinfo,n,sizeof(int),D); - n= (D->strip) ? 0 : f->sizelocvars; - DumpInt(n,D); - for (i=0; ilocvars[i].varname,D); - DumpInt(f->locvars[i].startpc,D); - DumpInt(f->locvars[i].endpc,D); - } - n= (D->strip) ? 0 : f->sizeupvalues; - DumpInt(n,D); - for (i=0; iupvalues[i].name,D); + +static void DumpDebug (const Proto *f, DumpState *D) { + int i, n; + n = (D->strip) ? 0 : f->sizelineinfo; + DumpInt(n, D); + DumpVector(f->lineinfo, n, D); + n = (D->strip) ? 0 : f->sizelocvars; + DumpInt(n, D); + for (i = 0; i < n; i++) { + DumpString(f->locvars[i].varname, D); + DumpInt(f->locvars[i].startpc, D); + DumpInt(f->locvars[i].endpc, D); + } + n = (D->strip) ? 0 : f->sizeupvalues; + DumpInt(n, D); + for (i = 0; i < n; i++) + DumpString(f->upvalues[i].name, D); } -static void DumpFunction(const Proto* f, DumpState* D) -{ - DumpInt(f->linedefined,D); - DumpInt(f->lastlinedefined,D); - DumpChar(f->numparams,D); - DumpChar(f->is_vararg,D); - DumpChar(f->maxstacksize,D); - DumpCode(f,D); - DumpConstants(f,D); - DumpUpvalues(f,D); - DumpDebug(f,D); + +static void DumpFunction (const Proto *f, TString *psource, DumpState *D) { + if (D->strip || f->source == psource) + DumpString(NULL, D); /* no debug info or same source as its parent */ + else + DumpString(f->source, D); + DumpInt(f->linedefined, D); + DumpInt(f->lastlinedefined, D); + DumpByte(f->numparams, D); + DumpByte(f->is_vararg, D); + DumpByte(f->maxstacksize, D); + DumpCode(f, D); + DumpConstants(f, D); + DumpUpvalues(f, D); + DumpProtos(f, D); + DumpDebug(f, D); } -static void DumpHeader(DumpState* D) -{ - lu_byte h[LUAC_HEADERSIZE]; - luaU_header(h); - DumpBlock(h,LUAC_HEADERSIZE,D); + +static void DumpHeader (DumpState *D) { + DumpLiteral(LUA_SIGNATURE, D); + DumpByte(LUAC_VERSION, D); + DumpByte(LUAC_FORMAT, D); + DumpLiteral(LUAC_DATA, D); + DumpByte(sizeof(int), D); + DumpByte(sizeof(size_t), D); + DumpByte(sizeof(Instruction), D); + DumpByte(sizeof(lua_Integer), D); + DumpByte(sizeof(lua_Number), D); + DumpInteger(LUAC_INT, D); + DumpNumber(LUAC_NUM, D); } + /* ** dump Lua function as precompiled chunk */ -int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) -{ - DumpState D; - D.L=L; - D.writer=w; - D.data=data; - D.strip=strip; - D.status=0; - DumpHeader(&D); - DumpFunction(f,&D); - return D.status; +int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data, + int strip) { + DumpState D; + D.L = L; + D.writer = w; + D.data = data; + D.strip = strip; + D.status = 0; + DumpHeader(&D); + DumpByte(f->sizeupvalues, &D); + DumpFunction(f, NULL, &D); + return D.status; } + diff --git a/depends/lua/src/lfunc.c b/depends/lua/src/lfunc.c index e90e1520ce..ccafbb8ab3 100644 --- a/depends/lua/src/lfunc.c +++ b/depends/lua/src/lfunc.c @@ -1,15 +1,17 @@ /* -** $Id: lfunc.c,v 2.30.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lfunc.c,v 2.45.1.1 2017/04/19 17:39:34 roberto Exp $ ** Auxiliary functions to manipulate prototypes and closures ** See Copyright Notice in lua.h */ - -#include - #define lfunc_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" #include "lfunc.h" @@ -20,95 +22,83 @@ -Closure *luaF_newCclosure (lua_State *L, int n) { - Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n), NULL, 0)->cl; - c->c.nupvalues = cast_byte(n); +CClosure *luaF_newCclosure (lua_State *L, int n) { + GCObject *o = luaC_newobj(L, LUA_TCCL, sizeCclosure(n)); + CClosure *c = gco2ccl(o); + c->nupvalues = cast_byte(n); return c; } -Closure *luaF_newLclosure (lua_State *L, int n) { - Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl; - c->l.p = NULL; - c->l.nupvalues = cast_byte(n); - while (n--) c->l.upvals[n] = NULL; +LClosure *luaF_newLclosure (lua_State *L, int n) { + GCObject *o = luaC_newobj(L, LUA_TLCL, sizeLclosure(n)); + LClosure *c = gco2lcl(o); + c->p = NULL; + c->nupvalues = cast_byte(n); + while (n--) c->upvals[n] = NULL; return c; } - -UpVal *luaF_newupval (lua_State *L) { - UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv; - uv->v = &uv->u.value; - setnilvalue(uv->v); - return uv; +/* +** fill a closure with new closed upvalues +*/ +void luaF_initupvals (lua_State *L, LClosure *cl) { + int i; + for (i = 0; i < cl->nupvalues; i++) { + UpVal *uv = luaM_new(L, UpVal); + uv->refcount = 1; + uv->v = &uv->u.value; /* make it closed */ + setnilvalue(uv->v); + cl->upvals[i] = uv; + } } UpVal *luaF_findupval (lua_State *L, StkId level) { - global_State *g = G(L); - GCObject **pp = &L->openupval; + UpVal **pp = &L->openupval; UpVal *p; UpVal *uv; - while (*pp != NULL && (p = gco2uv(*pp))->v >= level) { - GCObject *o = obj2gco(p); - lua_assert(p->v != &p->u.value); - lua_assert(!isold(o) || isold(obj2gco(L))); - if (p->v == level) { /* found a corresponding upvalue? */ - if (isdead(g, o)) /* is it dead? */ - changewhite(o); /* resurrect it */ - return p; - } - pp = &p->next; + lua_assert(isintwups(L) || L->openupval == NULL); + while (*pp != NULL && (p = *pp)->v >= level) { + lua_assert(upisopen(p)); + if (p->v == level) /* found a corresponding upvalue? */ + return p; /* return it */ + pp = &p->u.open.next; } - /* not found: create a new one */ - uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv; + /* not found: create a new upvalue */ + uv = luaM_new(L, UpVal); + uv->refcount = 0; + uv->u.open.next = *pp; /* link it to list of open upvalues */ + uv->u.open.touched = 1; + *pp = uv; uv->v = level; /* current value lives in the stack */ - uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */ - uv->u.l.next = g->uvhead.u.l.next; - uv->u.l.next->u.l.prev = uv; - g->uvhead.u.l.next = uv; - lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv); + if (!isintwups(L)) { /* thread not in list of threads with upvalues? */ + L->twups = G(L)->twups; /* link it to the list */ + G(L)->twups = L; + } return uv; } -static void unlinkupval (UpVal *uv) { - lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv); - uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */ - uv->u.l.prev->u.l.next = uv->u.l.next; -} - - -void luaF_freeupval (lua_State *L, UpVal *uv) { - if (uv->v != &uv->u.value) /* is it open? */ - unlinkupval(uv); /* remove from open list */ - luaM_free(L, uv); /* free upvalue */ -} - - void luaF_close (lua_State *L, StkId level) { UpVal *uv; - global_State *g = G(L); - while (L->openupval != NULL && (uv = gco2uv(L->openupval))->v >= level) { - GCObject *o = obj2gco(uv); - lua_assert(!isblack(o) && uv->v != &uv->u.value); - L->openupval = uv->next; /* remove from `open' list */ - if (isdead(g, o)) - luaF_freeupval(L, uv); /* free upvalue */ + while (L->openupval != NULL && (uv = L->openupval)->v >= level) { + lua_assert(upisopen(uv)); + L->openupval = uv->u.open.next; /* remove from 'open' list */ + if (uv->refcount == 0) /* no references? */ + luaM_free(L, uv); /* free upvalue */ else { - unlinkupval(uv); /* remove upvalue from 'uvhead' list */ setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */ uv->v = &uv->u.value; /* now current value lives here */ - gch(o)->next = g->allgc; /* link upvalue into 'allgc' list */ - g->allgc = o; - luaC_checkupvalcolor(g, uv); + luaC_upvalbarrier(L, uv); } } } Proto *luaF_newproto (lua_State *L) { - Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto), NULL, 0)->p; + GCObject *o = luaC_newobj(L, LUA_TPROTO, sizeof(Proto)); + Proto *f = gco2p(o); f->k = NULL; f->sizek = 0; f->p = NULL; @@ -144,7 +134,7 @@ void luaF_freeproto (lua_State *L, Proto *f) { /* -** Look for n-th local variable at line `line' in function `func'. +** Look for n-th local variable at line 'line' in function 'func'. ** Returns NULL if not found. */ const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { diff --git a/depends/lua/src/lgc.c b/depends/lua/src/lgc.c index 52460dcdd5..db4df82922 100644 --- a/depends/lua/src/lgc.c +++ b/depends/lua/src/lgc.c @@ -1,14 +1,17 @@ /* -** $Id: lgc.c,v 2.140.1.2 2013/04/26 18:22:05 roberto Exp $ +** $Id: lgc.c,v 2.215.1.2 2017/08/31 16:15:27 roberto Exp $ ** Garbage Collector ** See Copyright Notice in lua.h */ -#include - #define lgc_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" #include "ldebug.h" @@ -23,6 +26,11 @@ #include "ltm.h" +/* +** internal state for collector while inside the atomic phase. The +** collector should never be in this state while running regular code. +*/ +#define GCSinsideatomic (GCSpause + 1) /* ** cost of sweeping one element (the size of a small object divided @@ -33,8 +41,8 @@ /* maximum number of elements to sweep in each single step */ #define GCSWEEPMAX (cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4)) -/* maximum number of finalizers to call in each GC step */ -#define GCFINALIZENUM 4 +/* cost of calling one finalizer */ +#define GCFINALIZECOST GCSWEEPCOST /* @@ -52,18 +60,18 @@ /* -** 'makewhite' erases all color bits plus the old bit and then -** sets only the current white bit +** 'makewhite' erases all color bits then sets only the current white +** bit */ -#define maskcolors (~(bit2mask(BLACKBIT, OLDBIT) | WHITEBITS)) +#define maskcolors (~(bitmask(BLACKBIT) | WHITEBITS)) #define makewhite(g,x) \ - (gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) | luaC_white(g))) + (x->marked = cast_byte((x->marked & maskcolors) | luaC_white(g))) -#define white2gray(x) resetbits(gch(x)->marked, WHITEBITS) -#define black2gray(x) resetbit(gch(x)->marked, BLACKBIT) +#define white2gray(x) resetbits(x->marked, WHITEBITS) +#define black2gray(x) resetbit(x->marked, BLACKBIT) -#define isfinalized(x) testbit(gch(x)->marked, FINALIZEDBIT) +#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) #define checkdeadkey(n) lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n))) @@ -75,8 +83,13 @@ #define markvalue(g,o) { checkconsistency(o); \ if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } -#define markobject(g,t) { if ((t) && iswhite(obj2gco(t))) \ - reallymarkobject(g, obj2gco(t)); } +#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } + +/* +** mark an object that can be NULL (either because it is really optional, +** or it was stripped as debug info, or inside an uncompleted structure) +*/ +#define markobjectN(g,t) { if (t) markobject(g,t); } static void reallymarkobject (global_State *g, GCObject *o); @@ -95,33 +108,38 @@ static void reallymarkobject (global_State *g, GCObject *o); /* -** link table 'h' into list pointed by 'p' +** link collectable object 'o' into list pointed by 'p' */ -#define linktable(h,p) ((h)->gclist = *(p), *(p) = obj2gco(h)) +#define linkgclist(o,p) ((o)->gclist = (p), (p) = obj2gco(o)) /* -** if key is not marked, mark its entry as dead (therefore removing it -** from the table) +** If key is not marked, mark its entry as dead. This allows key to be +** collected, but keeps its entry in the table. A dead node is needed +** when Lua looks up for a key (it may be part of a chain) and when +** traversing a weak table (key might be removed from the table during +** traversal). Other places never manipulate dead keys, because its +** associated nil value is enough to signal that the entry is logically +** empty. */ static void removeentry (Node *n) { lua_assert(ttisnil(gval(n))); if (valiswhite(gkey(n))) - setdeadvalue(gkey(n)); /* unused and unmarked key; remove it */ + setdeadvalue(wgkey(n)); /* unused and unmarked key; remove it */ } /* ** tells whether a key or value can be cleared from a weak ** table. Non-collectable objects are never removed from weak -** tables. Strings behave as `values', so are never removed too. for +** tables. Strings behave as 'values', so are never removed too. for ** other objects: if really collected, cannot keep them; for objects ** being finalized, keep them in keys, but not in values */ static int iscleared (global_State *g, const TValue *o) { if (!iscollectable(o)) return 0; else if (ttisstring(o)) { - markobject(g, rawtsvalue(o)); /* strings are `values', so are never weak */ + markobject(g, tsvalue(o)); /* strings are 'values', so are never weak */ return 0; } else return iswhite(gcvalue(o)); @@ -130,14 +148,14 @@ static int iscleared (global_State *g, const TValue *o) { /* ** barrier that moves collector forward, that is, mark the white object -** being pointed by a black object. +** being pointed by a black object. (If in sweep phase, clear the black +** object to white [sweep it] to avoid other barrier calls for this +** same object.) */ void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) { global_State *g = G(L); lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o)); - lua_assert(g->gcstate != GCSpause); - lua_assert(gch(o)->tt != LUA_TTABLE); - if (keepinvariantout(g)) /* must keep invariant? */ + if (keepinvariant(g)) /* must keep invariant? */ reallymarkobject(g, v); /* restore invariant */ else { /* sweep phase */ lua_assert(issweepphase(g)); @@ -148,78 +166,52 @@ void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) { /* ** barrier that moves collector backward, that is, mark the black object -** pointing to a white object as gray again. (Current implementation -** only works for tables; access to 'gclist' is not uniform across -** different types.) +** pointing to a white object as gray again. */ -void luaC_barrierback_ (lua_State *L, GCObject *o) { +void luaC_barrierback_ (lua_State *L, Table *t) { global_State *g = G(L); - lua_assert(isblack(o) && !isdead(g, o) && gch(o)->tt == LUA_TTABLE); - black2gray(o); /* make object gray (again) */ - gco2t(o)->gclist = g->grayagain; - g->grayagain = o; + lua_assert(isblack(t) && !isdead(g, t)); + black2gray(t); /* make table gray (again) */ + linkgclist(t, g->grayagain); } /* -** barrier for prototypes. When creating first closure (cache is -** NULL), use a forward barrier; this may be the only closure of the -** prototype (if it is a "regular" function, with a single instance) -** and the prototype may be big, so it is better to avoid traversing -** it again. Otherwise, use a backward barrier, to avoid marking all -** possible instances. +** barrier for assignments to closed upvalues. Because upvalues are +** shared among closures, it is impossible to know the color of all +** closures pointing to it. So, we assume that the object being assigned +** must be marked. */ -LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c) { +void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) { global_State *g = G(L); - lua_assert(isblack(obj2gco(p))); - if (p->cache == NULL) { /* first time? */ - luaC_objbarrier(L, p, c); - } - else { /* use a backward barrier */ - black2gray(obj2gco(p)); /* make prototype gray (again) */ - p->gclist = g->grayagain; - g->grayagain = obj2gco(p); - } + GCObject *o = gcvalue(uv->v); + lua_assert(!upisopen(uv)); /* ensured by macro luaC_upvalbarrier */ + if (keepinvariant(g)) + markobject(g, o); } -/* -** check color (and invariants) for an upvalue that was closed, -** i.e., moved into the 'allgc' list -*/ -void luaC_checkupvalcolor (global_State *g, UpVal *uv) { - GCObject *o = obj2gco(uv); - lua_assert(!isblack(o)); /* open upvalues are never black */ - if (isgray(o)) { - if (keepinvariant(g)) { - resetoldbit(o); /* see MOVE OLD rule */ - gray2black(o); /* it is being visited now */ - markvalue(g, uv->v); - } - else { - lua_assert(issweepphase(g)); - makewhite(g, o); - } - } +void luaC_fix (lua_State *L, GCObject *o) { + global_State *g = G(L); + lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */ + white2gray(o); /* they will be gray forever */ + g->allgc = o->next; /* remove object from 'allgc' list */ + o->next = g->fixedgc; /* link it to 'fixedgc' list */ + g->fixedgc = o; } /* ** create a new collectable object (with given type and size) and link -** it to '*list'. 'offset' tells how many bytes to allocate before the -** object itself (used only by states). +** it to 'allgc' list. */ -GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, GCObject **list, - int offset) { +GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) { global_State *g = G(L); - char *raw = cast(char *, luaM_newobject(L, novariant(tt), sz)); - GCObject *o = obj2gco(raw + offset); - if (list == NULL) - list = &g->allgc; /* standard list for collectable objects */ - gch(o)->marked = luaC_white(g); - gch(o)->tt = tt; - gch(o)->next = *list; - *list = o; + GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz)); + o->marked = luaC_white(g); + o->tt = tt; + o->next = g->allgc; + g->allgc = o; return o; } @@ -241,57 +233,53 @@ GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, GCObject **list, ** upvalues are already linked in 'headuv' list.) */ static void reallymarkobject (global_State *g, GCObject *o) { - lu_mem size; + reentry: white2gray(o); - switch (gch(o)->tt) { - case LUA_TSHRSTR: - case LUA_TLNGSTR: { - size = sizestring(gco2ts(o)); - break; /* nothing else to mark; make it black */ + switch (o->tt) { + case LUA_TSHRSTR: { + gray2black(o); + g->GCmemtrav += sizelstring(gco2ts(o)->shrlen); + break; } - case LUA_TUSERDATA: { - Table *mt = gco2u(o)->metatable; - markobject(g, mt); - markobject(g, gco2u(o)->env); - size = sizeudata(gco2u(o)); + case LUA_TLNGSTR: { + gray2black(o); + g->GCmemtrav += sizelstring(gco2ts(o)->u.lnglen); break; } - case LUA_TUPVAL: { - UpVal *uv = gco2uv(o); - markvalue(g, uv->v); - if (uv->v != &uv->u.value) /* open? */ - return; /* open upvalues remain gray */ - size = sizeof(UpVal); + case LUA_TUSERDATA: { + TValue uvalue; + markobjectN(g, gco2u(o)->metatable); /* mark its metatable */ + gray2black(o); + g->GCmemtrav += sizeudata(gco2u(o)); + getuservalue(g->mainthread, gco2u(o), &uvalue); + if (valiswhite(&uvalue)) { /* markvalue(g, &uvalue); */ + o = gcvalue(&uvalue); + goto reentry; + } break; } case LUA_TLCL: { - gco2lcl(o)->gclist = g->gray; - g->gray = o; - return; + linkgclist(gco2lcl(o), g->gray); + break; } case LUA_TCCL: { - gco2ccl(o)->gclist = g->gray; - g->gray = o; - return; + linkgclist(gco2ccl(o), g->gray); + break; } case LUA_TTABLE: { - linktable(gco2t(o), &g->gray); - return; + linkgclist(gco2t(o), g->gray); + break; } case LUA_TTHREAD: { - gco2th(o)->gclist = g->gray; - g->gray = o; - return; + linkgclist(gco2th(o), g->gray); + break; } case LUA_TPROTO: { - gco2p(o)->gclist = g->gray; - g->gray = o; - return; + linkgclist(gco2p(o), g->gray); + break; } - default: lua_assert(0); return; + default: lua_assert(0); break; } - gray2black(o); - g->GCmemtrav += size; } @@ -301,7 +289,7 @@ static void reallymarkobject (global_State *g, GCObject *o) { static void markmt (global_State *g) { int i; for (i=0; i < LUA_NUMTAGS; i++) - markobject(g, g->mt[i]); + markobjectN(g, g->mt[i]); } @@ -310,29 +298,41 @@ static void markmt (global_State *g) { */ static void markbeingfnz (global_State *g) { GCObject *o; - for (o = g->tobefnz; o != NULL; o = gch(o)->next) { - makewhite(g, o); - reallymarkobject(g, o); - } + for (o = g->tobefnz; o != NULL; o = o->next) + markobject(g, o); } /* -** mark all values stored in marked open upvalues. (See comment in -** 'lstate.h'.) +** Mark all values stored in marked open upvalues from non-marked threads. +** (Values from marked threads were already marked when traversing the +** thread.) Remove from the list threads that no longer have upvalues and +** not-marked threads. */ static void remarkupvals (global_State *g) { - UpVal *uv; - for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) { - if (isgray(obj2gco(uv))) - markvalue(g, uv->v); + lua_State *thread; + lua_State **p = &g->twups; + while ((thread = *p) != NULL) { + lua_assert(!isblack(thread)); /* threads are never black */ + if (isgray(thread) && thread->openupval != NULL) + p = &thread->twups; /* keep marked thread with upvalues in the list */ + else { /* thread is not marked or without upvalues */ + UpVal *uv; + *p = thread->twups; /* remove thread from the list */ + thread->twups = thread; /* mark that it is out of list */ + for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) { + if (uv->u.open.touched) { + markvalue(g, uv->v); /* remark upvalue's value */ + uv->u.open.touched = 0; + } + } + } } } /* -** mark root set and reset all gray lists, to start a new -** incremental (or full) collection +** mark root set and reset all gray lists, to start a new collection */ static void restartcollection (global_State *g) { g->gray = g->grayagain = NULL; @@ -352,12 +352,18 @@ static void restartcollection (global_State *g) { ** ======================================================= */ +/* +** Traverse a table with weak values and link it to proper list. During +** propagate phase, keep it in 'grayagain' list, to be revisited in the +** atomic phase. In the atomic phase, if table has any white value, +** put it in 'weak' list, to be cleared. +*/ static void traverseweakvalue (global_State *g, Table *h) { Node *n, *limit = gnodelast(h); - /* if there is array part, assume it may have white values (do not - traverse it just to check) */ + /* if there is array part, assume it may have white values (it is not + worth traversing it now just to check) */ int hasclears = (h->sizearray > 0); - for (n = gnode(h, 0); n < limit; n++) { + for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ checkdeadkey(n); if (ttisnil(gval(n))) /* entry is empty? */ removeentry(n); /* remove it */ @@ -368,20 +374,30 @@ static void traverseweakvalue (global_State *g, Table *h) { hasclears = 1; /* table will have to be cleared */ } } - if (hasclears) - linktable(h, &g->weak); /* has to be cleared later */ - else /* no white values */ - linktable(h, &g->grayagain); /* no need to clean */ + if (g->gcstate == GCSpropagate) + linkgclist(h, g->grayagain); /* must retraverse it in atomic phase */ + else if (hasclears) + linkgclist(h, g->weak); /* has to be cleared later */ } +/* +** Traverse an ephemeron table and link it to proper list. Returns true +** iff any object was marked during this traversal (which implies that +** convergence has to continue). During propagation phase, keep table +** in 'grayagain' list, to be visited again in the atomic phase. In +** the atomic phase, if table has any white->white entry, it has to +** be revisited during ephemeron convergence (as that key may turn +** black). Otherwise, if it has any white key, table has to be cleared +** (in the atomic phase). +*/ static int traverseephemeron (global_State *g, Table *h) { int marked = 0; /* true if an object is marked in this traversal */ int hasclears = 0; /* true if table has white keys */ - int prop = 0; /* true if table has entry "white-key -> white-value" */ + int hasww = 0; /* true if table has entry "white-key -> white-value" */ Node *n, *limit = gnodelast(h); - int i; - /* traverse array part (numeric keys are 'strong') */ + unsigned int i; + /* traverse array part */ for (i = 0; i < h->sizearray; i++) { if (valiswhite(&h->array[i])) { marked = 1; @@ -396,26 +412,27 @@ static int traverseephemeron (global_State *g, Table *h) { else if (iscleared(g, gkey(n))) { /* key is not marked (yet)? */ hasclears = 1; /* table must be cleared */ if (valiswhite(gval(n))) /* value not marked yet? */ - prop = 1; /* must propagate again */ + hasww = 1; /* white-white entry */ } else if (valiswhite(gval(n))) { /* value not marked yet? */ marked = 1; reallymarkobject(g, gcvalue(gval(n))); /* mark it now */ } } - if (prop) - linktable(h, &g->ephemeron); /* have to propagate again */ - else if (hasclears) /* does table have white keys? */ - linktable(h, &g->allweak); /* may have to clean white keys */ - else /* no white keys */ - linktable(h, &g->grayagain); /* no need to clean */ + /* link table into proper list */ + if (g->gcstate == GCSpropagate) + linkgclist(h, g->grayagain); /* must retraverse it in atomic phase */ + else if (hasww) /* table has white->white entries? */ + linkgclist(h, g->ephemeron); /* have to propagate again */ + else if (hasclears) /* table has white keys? */ + linkgclist(h, g->allweak); /* may have to clean white keys */ return marked; } static void traversestrongtable (global_State *g, Table *h) { Node *n, *limit = gnodelast(h); - int i; + unsigned int i; for (i = 0; i < h->sizearray; i++) /* traverse array part */ markvalue(g, &h->array[i]); for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ @@ -434,39 +451,44 @@ static void traversestrongtable (global_State *g, Table *h) { static lu_mem traversetable (global_State *g, Table *h) { const char *weakkey, *weakvalue; const TValue *mode = gfasttm(g, h->metatable, TM_MODE); - markobject(g, h->metatable); + markobjectN(g, h->metatable); if (mode && ttisstring(mode) && /* is there a weak mode? */ ((weakkey = strchr(svalue(mode), 'k')), (weakvalue = strchr(svalue(mode), 'v')), (weakkey || weakvalue))) { /* is really weak? */ - black2gray(obj2gco(h)); /* keep table gray */ + black2gray(h); /* keep table gray */ if (!weakkey) /* strong keys? */ traverseweakvalue(g, h); else if (!weakvalue) /* strong values? */ traverseephemeron(g, h); else /* all weak */ - linktable(h, &g->allweak); /* nothing to traverse now */ + linkgclist(h, g->allweak); /* nothing to traverse now */ } else /* not weak */ traversestrongtable(g, h); return sizeof(Table) + sizeof(TValue) * h->sizearray + - sizeof(Node) * cast(size_t, sizenode(h)); + sizeof(Node) * cast(size_t, allocsizenode(h)); } +/* +** Traverse a prototype. (While a prototype is being build, its +** arrays can be larger than needed; the extra slots are filled with +** NULL, so the use of 'markobjectN') +*/ static int traverseproto (global_State *g, Proto *f) { int i; - if (f->cache && iswhite(obj2gco(f->cache))) + if (f->cache && iswhite(f->cache)) f->cache = NULL; /* allow cache to be collected */ - markobject(g, f->source); + markobjectN(g, f->source); for (i = 0; i < f->sizek; i++) /* mark literals */ markvalue(g, &f->k[i]); for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */ - markobject(g, f->upvalues[i].name); + markobjectN(g, f->upvalues[i].name); for (i = 0; i < f->sizep; i++) /* mark nested protos */ - markobject(g, f->p[i]); + markobjectN(g, f->p[i]); for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */ - markobject(g, f->locvars[i].varname); + markobjectN(g, f->locvars[i].varname); return sizeof(Proto) + sizeof(Instruction) * f->sizecode + sizeof(Proto *) * f->sizep + sizeof(TValue) * f->sizek + @@ -483,34 +505,50 @@ static lu_mem traverseCclosure (global_State *g, CClosure *cl) { return sizeCclosure(cl->nupvalues); } +/* +** open upvalues point to values in a thread, so those values should +** be marked when the thread is traversed except in the atomic phase +** (because then the value cannot be changed by the thread and the +** thread may not be traversed again) +*/ static lu_mem traverseLclosure (global_State *g, LClosure *cl) { int i; - markobject(g, cl->p); /* mark its prototype */ - for (i = 0; i < cl->nupvalues; i++) /* mark its upvalues */ - markobject(g, cl->upvals[i]); + markobjectN(g, cl->p); /* mark its prototype */ + for (i = 0; i < cl->nupvalues; i++) { /* mark its upvalues */ + UpVal *uv = cl->upvals[i]; + if (uv != NULL) { + if (upisopen(uv) && g->gcstate != GCSinsideatomic) + uv->u.open.touched = 1; /* can be marked in 'remarkupvals' */ + else + markvalue(g, uv->v); + } + } return sizeLclosure(cl->nupvalues); } -static lu_mem traversestack (global_State *g, lua_State *th) { - int n = 0; +static lu_mem traversethread (global_State *g, lua_State *th) { StkId o = th->stack; if (o == NULL) return 1; /* stack not completely built yet */ + lua_assert(g->gcstate == GCSinsideatomic || + th->openupval == NULL || isintwups(th)); for (; o < th->top; o++) /* mark live elements in the stack */ markvalue(g, o); - if (g->gcstate == GCSatomic) { /* final traversal? */ + if (g->gcstate == GCSinsideatomic) { /* final traversal? */ StkId lim = th->stack + th->stacksize; /* real end of stack */ for (; o < lim; o++) /* clear not-marked stack slice */ setnilvalue(o); + /* 'remarkupvals' may have removed thread from 'twups' list */ + if (!isintwups(th) && th->openupval != NULL) { + th->twups = g->twups; /* link it back to the list */ + g->twups = th; + } } - else { /* count call infos to compute size */ - CallInfo *ci; - for (ci = &th->base_ci; ci != th->ci; ci = ci->next) - n++; - } - return sizeof(lua_State) + sizeof(TValue) * th->stacksize + - sizeof(CallInfo) * n; + else if (g->gckind != KGC_EMERGENCY) + luaD_shrinkstack(th); /* do not change stack in emergency cycle */ + return (sizeof(lua_State) + sizeof(TValue) * th->stacksize + + sizeof(CallInfo) * th->nci); } @@ -523,7 +561,7 @@ static void propagatemark (global_State *g) { GCObject *o = g->gray; lua_assert(isgray(o)); gray2black(o); - switch (gch(o)->tt) { + switch (o->tt) { case LUA_TTABLE: { Table *h = gco2t(o); g->gray = h->gclist; /* remove from 'gray' list */ @@ -545,10 +583,9 @@ static void propagatemark (global_State *g) { case LUA_TTHREAD: { lua_State *th = gco2th(o); g->gray = th->gclist; /* remove from 'gray' list */ - th->gclist = g->grayagain; - g->grayagain = o; /* insert into 'grayagain' list */ + linkgclist(th, g->grayagain); /* insert into 'grayagain' list */ black2gray(o); - size = traversestack(g, th); + size = traversethread(g, th); break; } case LUA_TPROTO: { @@ -568,35 +605,12 @@ static void propagateall (global_State *g) { } -static void propagatelist (global_State *g, GCObject *l) { - lua_assert(g->gray == NULL); /* no grays left */ - g->gray = l; - propagateall(g); /* traverse all elements from 'l' */ -} - -/* -** retraverse all gray lists. Because tables may be reinserted in other -** lists when traversed, traverse the original lists to avoid traversing -** twice the same table (which is not wrong, but inefficient) -*/ -static void retraversegrays (global_State *g) { - GCObject *weak = g->weak; /* save original lists */ - GCObject *grayagain = g->grayagain; - GCObject *ephemeron = g->ephemeron; - g->weak = g->grayagain = g->ephemeron = NULL; - propagateall(g); /* traverse main gray list */ - propagatelist(g, grayagain); - propagatelist(g, weak); - propagatelist(g, ephemeron); -} - - static void convergeephemerons (global_State *g) { int changed; do { GCObject *w; GCObject *next = g->ephemeron; /* get ephemeron list */ - g->ephemeron = NULL; /* tables will return to this list when traversed */ + g->ephemeron = NULL; /* tables may return to this list when traversed */ changed = 0; while ((w = next) != NULL) { next = gco2t(w)->gclist; @@ -629,8 +643,9 @@ static void clearkeys (global_State *g, GCObject *l, GCObject *f) { for (n = gnode(h, 0); n < limit; n++) { if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) { setnilvalue(gval(n)); /* remove value ... */ - removeentry(n); /* and remove entry from table */ } + if (ttisnil(gval(n))) /* is entry empty? */ + removeentry(n); /* remove entry from table */ } } } @@ -644,7 +659,7 @@ static void clearvalues (global_State *g, GCObject *l, GCObject *f) { for (; l != f; l = gco2t(l)->gclist) { Table *h = gco2t(l); Node *n, *limit = gnodelast(h); - int i; + unsigned int i; for (i = 0; i < h->sizearray; i++) { TValue *o = &h->array[i]; if (iscleared(g, o)) /* value was collected? */ @@ -660,26 +675,45 @@ static void clearvalues (global_State *g, GCObject *l, GCObject *f) { } +void luaC_upvdeccount (lua_State *L, UpVal *uv) { + lua_assert(uv->refcount > 0); + uv->refcount--; + if (uv->refcount == 0 && !upisopen(uv)) + luaM_free(L, uv); +} + + +static void freeLclosure (lua_State *L, LClosure *cl) { + int i; + for (i = 0; i < cl->nupvalues; i++) { + UpVal *uv = cl->upvals[i]; + if (uv) + luaC_upvdeccount(L, uv); + } + luaM_freemem(L, cl, sizeLclosure(cl->nupvalues)); +} + + static void freeobj (lua_State *L, GCObject *o) { - switch (gch(o)->tt) { + switch (o->tt) { case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break; case LUA_TLCL: { - luaM_freemem(L, o, sizeLclosure(gco2lcl(o)->nupvalues)); + freeLclosure(L, gco2lcl(o)); break; } case LUA_TCCL: { luaM_freemem(L, o, sizeCclosure(gco2ccl(o)->nupvalues)); break; } - case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break; case LUA_TTABLE: luaH_free(L, gco2t(o)); break; case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break; case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break; case LUA_TSHRSTR: - G(L)->strt.nuse--; - /* go through */ + luaS_remove(L, gco2ts(o)); /* remove it from hash table */ + luaM_freemem(L, o, sizelstring(gco2ts(o)->shrlen)); + break; case LUA_TLNGSTR: { - luaM_freemem(L, o, sizestring(gco2ts(o))); + luaM_freemem(L, o, sizelstring(gco2ts(o)->u.lnglen)); break; } default: lua_assert(0); @@ -691,61 +725,27 @@ static void freeobj (lua_State *L, GCObject *o) { static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count); -/* -** sweep the (open) upvalues of a thread and resize its stack and -** list of call-info structures. -*/ -static void sweepthread (lua_State *L, lua_State *L1) { - if (L1->stack == NULL) return; /* stack not completely built yet */ - sweepwholelist(L, &L1->openupval); /* sweep open upvalues */ - luaE_freeCI(L1); /* free extra CallInfo slots */ - /* should not change the stack during an emergency gc cycle */ - if (G(L)->gckind != KGC_EMERGENCY) - luaD_shrinkstack(L1); -} - - /* ** sweep at most 'count' elements from a list of GCObjects erasing dead -** objects, where a dead (not alive) object is one marked with the "old" -** (non current) white and not fixed. -** In non-generational mode, change all non-dead objects back to white, -** preparing for next collection cycle. -** In generational mode, keep black objects black, and also mark them as -** old; stop when hitting an old object, as all objects after that -** one will be old too. -** When object is a thread, sweep its list of open upvalues too. +** objects, where a dead object is one marked with the old (non current) +** white; change all non-dead objects back to white, preparing for next +** collection cycle. Return where to continue the traversal or NULL if +** list is finished. */ static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) { global_State *g = G(L); int ow = otherwhite(g); - int toclear, toset; /* bits to clear and to set in all live objects */ - int tostop; /* stop sweep when this is true */ - if (isgenerational(g)) { /* generational mode? */ - toclear = ~0; /* clear nothing */ - toset = bitmask(OLDBIT); /* set the old bit of all surviving objects */ - tostop = bitmask(OLDBIT); /* do not sweep old generation */ - } - else { /* normal mode */ - toclear = maskcolors; /* clear all color bits + old bit */ - toset = luaC_white(g); /* make object white */ - tostop = 0; /* do not stop */ - } + int white = luaC_white(g); /* current white */ while (*p != NULL && count-- > 0) { GCObject *curr = *p; - int marked = gch(curr)->marked; + int marked = curr->marked; if (isdeadm(ow, marked)) { /* is 'curr' dead? */ - *p = gch(curr)->next; /* remove 'curr' from list */ + *p = curr->next; /* remove 'curr' from list */ freeobj(L, curr); /* erase 'curr' */ } - else { - if (testbits(marked, tostop)) - return NULL; /* stop sweeping this list */ - if (gch(curr)->tt == LUA_TTHREAD) - sweepthread(L, gco2th(curr)); /* sweep thread's upvalues */ - /* update marks */ - gch(curr)->marked = cast_byte((marked & toclear) | toset); - p = &gch(curr)->next; /* go to next element */ + else { /* change mark to 'white' */ + curr->marked = cast_byte((marked & maskcolors) | white); + p = &curr->next; /* go to next element */ } } return (*p == NULL) ? NULL : p; @@ -755,14 +755,11 @@ static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) { /* ** sweep a list until a live object (or end of list) */ -static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) { - GCObject ** old = p; - int i = 0; +static GCObject **sweeptolive (lua_State *L, GCObject **p) { + GCObject **old = p; do { - i++; p = sweeplist(L, p, 1); } while (p == old); - if (n) *n += i; return p; } @@ -775,26 +772,27 @@ static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) { ** ======================================================= */ -static void checkSizes (lua_State *L) { - global_State *g = G(L); - if (g->gckind != KGC_EMERGENCY) { /* do not change sizes in emergency */ - int hs = g->strt.size / 2; /* half the size of the string table */ - if (g->strt.nuse < cast(lu_int32, hs)) /* using less than that half? */ - luaS_resize(L, hs); /* halve its size */ - luaZ_freebuffer(L, &g->buff); /* free concatenation buffer */ +/* +** If possible, shrink string table +*/ +static void checkSizes (lua_State *L, global_State *g) { + if (g->gckind != KGC_EMERGENCY) { + l_mem olddebt = g->GCdebt; + if (g->strt.nuse < g->strt.size / 4) /* string table too big? */ + luaS_resize(L, g->strt.size / 2); /* shrink it a little */ + g->GCestimate += g->GCdebt - olddebt; /* update estimate */ } } static GCObject *udata2finalize (global_State *g) { GCObject *o = g->tobefnz; /* get first element */ - lua_assert(isfinalized(o)); - g->tobefnz = gch(o)->next; /* remove it from 'tobefnz' list */ - gch(o)->next = g->allgc; /* return it to 'allgc' list */ + lua_assert(tofinalize(o)); + g->tobefnz = o->next; /* remove it from 'tobefnz' list */ + o->next = g->allgc; /* return it to 'allgc' list */ g->allgc = o; - resetbit(gch(o)->marked, SEPARATED); /* mark that it is not in 'tobefnz' */ - lua_assert(!isold(o)); /* see MOVE OLD rule */ - if (!keepinvariantout(g)) /* not keeping invariant? */ + resetbit(o->marked, FINALIZEDBIT); /* object is "normal" again */ + if (issweepphase(g)) makewhite(g, o); /* "sweep" object */ return o; } @@ -802,7 +800,7 @@ static GCObject *udata2finalize (global_State *g) { static void dothecall (lua_State *L, void *ud) { UNUSED(ud); - luaD_call(L, L->top - 2, 0, 0); + luaD_callnoyield(L, L->top - 2, 0); } @@ -821,7 +819,9 @@ static void GCTM (lua_State *L, int propagateerrors) { setobj2s(L, L->top, tm); /* push finalizer... */ setobj2s(L, L->top + 1, &v); /* ... and its argument */ L->top += 2; /* and (next line) call the finalizer */ + L->ci->callstatus |= CIST_FIN; /* will run a finalizer */ status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0); + L->ci->callstatus &= ~CIST_FIN; /* not running a finalizer anymore */ L->allowhook = oldah; /* restore hooks */ g->gcrunning = running; /* restore state */ if (status != LUA_OK && propagateerrors) { /* error while running __gc? */ @@ -838,29 +838,58 @@ static void GCTM (lua_State *L, int propagateerrors) { } +/* +** call a few (up to 'g->gcfinnum') finalizers +*/ +static int runafewfinalizers (lua_State *L) { + global_State *g = G(L); + unsigned int i; + lua_assert(!g->tobefnz || g->gcfinnum > 0); + for (i = 0; g->tobefnz && i < g->gcfinnum; i++) + GCTM(L, 1); /* call one finalizer */ + g->gcfinnum = (!g->tobefnz) ? 0 /* nothing more to finalize? */ + : g->gcfinnum * 2; /* else call a few more next time */ + return i; +} + + +/* +** call all pending finalizers +*/ +static void callallpendingfinalizers (lua_State *L) { + global_State *g = G(L); + while (g->tobefnz) + GCTM(L, 0); +} + + +/* +** find last 'next' field in list 'p' list (to add elements in its end) +*/ +static GCObject **findlast (GCObject **p) { + while (*p != NULL) + p = &(*p)->next; + return p; +} + + /* ** move all unreachable objects (or 'all' objects) that need ** finalization from list 'finobj' to list 'tobefnz' (to be finalized) */ -static void separatetobefnz (lua_State *L, int all) { - global_State *g = G(L); - GCObject **p = &g->finobj; +static void separatetobefnz (global_State *g, int all) { GCObject *curr; - GCObject **lastnext = &g->tobefnz; - /* find last 'next' field in 'tobefnz' list (to add elements in its end) */ - while (*lastnext != NULL) - lastnext = &gch(*lastnext)->next; + GCObject **p = &g->finobj; + GCObject **lastnext = findlast(&g->tobefnz); while ((curr = *p) != NULL) { /* traverse all finalizable objects */ - lua_assert(!isfinalized(curr)); - lua_assert(testbit(gch(curr)->marked, SEPARATED)); + lua_assert(tofinalize(curr)); if (!(iswhite(curr) || all)) /* not being collected? */ - p = &gch(curr)->next; /* don't bother with it */ + p = &curr->next; /* don't bother with it */ else { - l_setbit(gch(curr)->marked, FINALIZEDBIT); /* won't be finalized again */ - *p = gch(curr)->next; /* remove 'curr' from 'finobj' list */ - gch(curr)->next = *lastnext; /* link at the end of 'tobefnz' list */ + *p = curr->next; /* remove 'curr' from 'finobj' list */ + curr->next = *lastnext; /* link at the end of 'tobefnz' list */ *lastnext = curr; - lastnext = &gch(curr)->next; + lastnext = &curr->next; } } } @@ -872,33 +901,29 @@ static void separatetobefnz (lua_State *L, int all) { */ void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { global_State *g = G(L); - if (testbit(gch(o)->marked, SEPARATED) || /* obj. is already separated... */ - isfinalized(o) || /* ... or is finalized... */ - gfasttm(g, mt, TM_GC) == NULL) /* or has no finalizer? */ + if (tofinalize(o) || /* obj. is already marked... */ + gfasttm(g, mt, TM_GC) == NULL) /* or has no finalizer? */ return; /* nothing to be done */ else { /* move 'o' to 'finobj' list */ GCObject **p; - GCheader *ho = gch(o); - if (g->sweepgc == &ho->next) { /* avoid removing current sweep object */ - lua_assert(issweepphase(g)); - g->sweepgc = sweeptolive(L, g->sweepgc, NULL); + if (issweepphase(g)) { + makewhite(g, o); /* "sweep" object 'o' */ + if (g->sweepgc == &o->next) /* should not remove 'sweepgc' object */ + g->sweepgc = sweeptolive(L, g->sweepgc); /* change 'sweepgc' */ } /* search for pointer pointing to 'o' */ - for (p = &g->allgc; *p != o; p = &gch(*p)->next) { /* empty */ } - *p = ho->next; /* remove 'o' from root list */ - ho->next = g->finobj; /* link it in list 'finobj' */ + for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ } + *p = o->next; /* remove 'o' from 'allgc' list */ + o->next = g->finobj; /* link it in 'finobj' list */ g->finobj = o; - l_setbit(ho->marked, SEPARATED); /* mark it as such */ - if (!keepinvariantout(g)) /* not keeping invariant? */ - makewhite(g, o); /* "sweep" object */ - else - resetoldbit(o); /* see MOVE OLD rule */ + l_setbit(o->marked, FINALIZEDBIT); /* mark it as such */ } } /* }====================================================== */ + /* ** {====================================================== ** GC control @@ -907,195 +932,164 @@ void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { /* -** set a reasonable "time" to wait before starting a new GC cycle; -** cycle will start when memory use hits threshold +** Set a reasonable "time" to wait before starting a new GC cycle; cycle +** will start when memory use hits threshold. (Division by 'estimate' +** should be OK: it cannot be zero (because Lua cannot even start with +** less than PAUSEADJ bytes). */ -static void setpause (global_State *g, l_mem estimate) { - l_mem debt, threshold; - estimate = estimate / PAUSEADJ; /* adjust 'estimate' */ +static void setpause (global_State *g) { + l_mem threshold, debt; + l_mem estimate = g->GCestimate / PAUSEADJ; /* adjust 'estimate' */ + lua_assert(estimate > 0); threshold = (g->gcpause < MAX_LMEM / estimate) /* overflow? */ ? estimate * g->gcpause /* no overflow */ : MAX_LMEM; /* overflow; truncate to maximum */ - debt = -cast(l_mem, threshold - gettotalbytes(g)); + debt = gettotalbytes(g) - threshold; luaE_setdebt(g, debt); } -#define sweepphases \ - (bitmask(GCSsweepstring) | bitmask(GCSsweepudata) | bitmask(GCSsweep)) - - -/* -** enter first sweep phase (strings) and prepare pointers for other -** sweep phases. The calls to 'sweeptolive' make pointers point to an -** object inside the list (instead of to the header), so that the real -** sweep do not need to skip objects created between "now" and the start -** of the real sweep. -** Returns how many objects it swept. -*/ -static int entersweep (lua_State *L) { - global_State *g = G(L); - int n = 0; - g->gcstate = GCSsweepstring; - lua_assert(g->sweepgc == NULL && g->sweepfin == NULL); - /* prepare to sweep strings, finalizable objects, and regular objects */ - g->sweepstrgc = 0; - g->sweepfin = sweeptolive(L, &g->finobj, &n); - g->sweepgc = sweeptolive(L, &g->allgc, &n); - return n; -} - - -/* -** change GC mode -*/ -void luaC_changemode (lua_State *L, int mode) { - global_State *g = G(L); - if (mode == g->gckind) return; /* nothing to change */ - if (mode == KGC_GEN) { /* change to generational mode */ - /* make sure gray lists are consistent */ - luaC_runtilstate(L, bitmask(GCSpropagate)); - g->GCestimate = gettotalbytes(g); - g->gckind = KGC_GEN; - } - else { /* change to incremental mode */ - /* sweep all objects to turn them back to white - (as white has not changed, nothing extra will be collected) */ - g->gckind = KGC_NORMAL; - entersweep(L); - luaC_runtilstate(L, ~sweepphases); - } -} - - /* -** call all pending finalizers +** Enter first sweep phase. +** The call to 'sweeplist' tries to make pointer point to an object +** inside the list (instead of to the header), so that the real sweep do +** not need to skip objects created between "now" and the start of the +** real sweep. */ -static void callallpendingfinalizers (lua_State *L, int propagateerrors) { +static void entersweep (lua_State *L) { global_State *g = G(L); - while (g->tobefnz) { - resetoldbit(g->tobefnz); - GCTM(L, propagateerrors); - } + g->gcstate = GCSswpallgc; + lua_assert(g->sweepgc == NULL); + g->sweepgc = sweeplist(L, &g->allgc, 1); } void luaC_freeallobjects (lua_State *L) { global_State *g = G(L); - int i; - separatetobefnz(L, 1); /* separate all objects with finalizers */ + separatetobefnz(g, 1); /* separate all objects with finalizers */ lua_assert(g->finobj == NULL); - callallpendingfinalizers(L, 0); + callallpendingfinalizers(L); + lua_assert(g->tobefnz == NULL); g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */ g->gckind = KGC_NORMAL; - sweepwholelist(L, &g->finobj); /* finalizers can create objs. in 'finobj' */ + sweepwholelist(L, &g->finobj); sweepwholelist(L, &g->allgc); - for (i = 0; i < g->strt.size; i++) /* free all string lists */ - sweepwholelist(L, &g->strt.hash[i]); + sweepwholelist(L, &g->fixedgc); /* collect fixed objects */ lua_assert(g->strt.nuse == 0); } static l_mem atomic (lua_State *L) { global_State *g = G(L); - l_mem work = -cast(l_mem, g->GCmemtrav); /* start counting work */ + l_mem work; GCObject *origweak, *origall; - lua_assert(!iswhite(obj2gco(g->mainthread))); + GCObject *grayagain = g->grayagain; /* save original list */ + lua_assert(g->ephemeron == NULL && g->weak == NULL); + lua_assert(!iswhite(g->mainthread)); + g->gcstate = GCSinsideatomic; + g->GCmemtrav = 0; /* start counting work */ markobject(g, L); /* mark running thread */ /* registry and global metatables may be changed by API */ markvalue(g, &g->l_registry); - markmt(g); /* mark basic metatables */ + markmt(g); /* mark global metatables */ /* remark occasional upvalues of (maybe) dead threads */ remarkupvals(g); propagateall(g); /* propagate changes */ - work += g->GCmemtrav; /* stop counting (do not (re)count grays) */ - /* traverse objects caught by write barrier and by 'remarkupvals' */ - retraversegrays(g); - work -= g->GCmemtrav; /* restart counting */ + work = g->GCmemtrav; /* stop counting (do not recount 'grayagain') */ + g->gray = grayagain; + propagateall(g); /* traverse 'grayagain' list */ + g->GCmemtrav = 0; /* restart counting */ convergeephemerons(g); /* at this point, all strongly accessible objects are marked. */ - /* clear values from weak tables, before checking finalizers */ + /* Clear values from weak tables, before checking finalizers */ clearvalues(g, g->weak, NULL); clearvalues(g, g->allweak, NULL); origweak = g->weak; origall = g->allweak; work += g->GCmemtrav; /* stop counting (objects being finalized) */ - separatetobefnz(L, 0); /* separate objects to be finalized */ + separatetobefnz(g, 0); /* separate objects to be finalized */ + g->gcfinnum = 1; /* there may be objects to be finalized */ markbeingfnz(g); /* mark objects that will be finalized */ - propagateall(g); /* remark, to propagate `preserveness' */ - work -= g->GCmemtrav; /* restart counting */ + propagateall(g); /* remark, to propagate 'resurrection' */ + g->GCmemtrav = 0; /* restart counting */ convergeephemerons(g); /* at this point, all resurrected objects are marked. */ /* remove dead objects from weak tables */ clearkeys(g, g->ephemeron, NULL); /* clear keys from all ephemeron tables */ - clearkeys(g, g->allweak, NULL); /* clear keys from all allweak tables */ + clearkeys(g, g->allweak, NULL); /* clear keys from all 'allweak' tables */ /* clear values from resurrected weak tables */ clearvalues(g, g->weak, origweak); clearvalues(g, g->allweak, origall); + luaS_clearcache(g); g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */ work += g->GCmemtrav; /* complete counting */ return work; /* estimate of memory marked by 'atomic' */ } +static lu_mem sweepstep (lua_State *L, global_State *g, + int nextstate, GCObject **nextlist) { + if (g->sweepgc) { + l_mem olddebt = g->GCdebt; + g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX); + g->GCestimate += g->GCdebt - olddebt; /* update estimate */ + if (g->sweepgc) /* is there still something to sweep? */ + return (GCSWEEPMAX * GCSWEEPCOST); + } + /* else enter next state */ + g->gcstate = nextstate; + g->sweepgc = nextlist; + return 0; +} + + static lu_mem singlestep (lua_State *L) { global_State *g = G(L); switch (g->gcstate) { case GCSpause: { - /* start to count memory traversed */ g->GCmemtrav = g->strt.size * sizeof(GCObject*); - lua_assert(!isgenerational(g)); restartcollection(g); g->gcstate = GCSpropagate; return g->GCmemtrav; } case GCSpropagate: { - if (g->gray) { - lu_mem oldtrav = g->GCmemtrav; - propagatemark(g); - return g->GCmemtrav - oldtrav; /* memory traversed in this step */ - } - else { /* no more `gray' objects */ - lu_mem work; - int sw; - g->gcstate = GCSatomic; /* finish mark phase */ - g->GCestimate = g->GCmemtrav; /* save what was counted */; - work = atomic(L); /* add what was traversed by 'atomic' */ - g->GCestimate += work; /* estimate of total memory traversed */ - sw = entersweep(L); - return work + sw * GCSWEEPCOST; - } + g->GCmemtrav = 0; + lua_assert(g->gray); + propagatemark(g); + if (g->gray == NULL) /* no more gray objects? */ + g->gcstate = GCSatomic; /* finish propagate phase */ + return g->GCmemtrav; /* memory traversed in this step */ } - case GCSsweepstring: { - int i; - for (i = 0; i < GCSWEEPMAX && g->sweepstrgc + i < g->strt.size; i++) - sweepwholelist(L, &g->strt.hash[g->sweepstrgc + i]); - g->sweepstrgc += i; - if (g->sweepstrgc >= g->strt.size) /* no more strings to sweep? */ - g->gcstate = GCSsweepudata; - return i * GCSWEEPCOST; + case GCSatomic: { + lu_mem work; + propagateall(g); /* make sure gray list is empty */ + work = atomic(L); /* work is what was traversed by 'atomic' */ + entersweep(L); + g->GCestimate = gettotalbytes(g); /* first estimate */; + return work; } - case GCSsweepudata: { - if (g->sweepfin) { - g->sweepfin = sweeplist(L, g->sweepfin, GCSWEEPMAX); - return GCSWEEPMAX*GCSWEEPCOST; - } - else { - g->gcstate = GCSsweep; - return 0; - } + case GCSswpallgc: { /* sweep "regular" objects */ + return sweepstep(L, g, GCSswpfinobj, &g->finobj); + } + case GCSswpfinobj: { /* sweep objects with finalizers */ + return sweepstep(L, g, GCSswptobefnz, &g->tobefnz); } - case GCSsweep: { - if (g->sweepgc) { - g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX); - return GCSWEEPMAX*GCSWEEPCOST; + case GCSswptobefnz: { /* sweep objects to be finalized */ + return sweepstep(L, g, GCSswpend, NULL); + } + case GCSswpend: { /* finish sweeps */ + makewhite(g, g->mainthread); /* sweep main thread */ + checkSizes(L, g); + g->gcstate = GCScallfin; + return 0; + } + case GCScallfin: { /* call remaining finalizers */ + if (g->tobefnz && g->gckind != KGC_EMERGENCY) { + int n = runafewfinalizers(L); + return (n * GCFINALIZECOST); } - else { - /* sweep main thread */ - GCObject *mt = obj2gco(g->mainthread); - sweeplist(L, &mt, 1); - checkSizes(L); + else { /* emergency mode or no more finalizers */ g->gcstate = GCSpause; /* finish collection */ - return GCSWEEPCOST; + return 0; } } default: lua_assert(0); return 0; @@ -1114,105 +1108,70 @@ void luaC_runtilstate (lua_State *L, int statesmask) { } -static void generationalcollection (lua_State *L) { - global_State *g = G(L); - lua_assert(g->gcstate == GCSpropagate); - if (g->GCestimate == 0) { /* signal for another major collection? */ - luaC_fullgc(L, 0); /* perform a full regular collection */ - g->GCestimate = gettotalbytes(g); /* update control */ - } +/* +** get GC debt and convert it from Kb to 'work units' (avoid zero debt +** and overflows) +*/ +static l_mem getdebt (global_State *g) { + l_mem debt = g->GCdebt; + int stepmul = g->gcstepmul; + if (debt <= 0) return 0; /* minimal debt */ else { - lu_mem estimate = g->GCestimate; - luaC_runtilstate(L, bitmask(GCSpause)); /* run complete (minor) cycle */ - g->gcstate = GCSpropagate; /* skip restart */ - if (gettotalbytes(g) > (estimate / 100) * g->gcmajorinc) - g->GCestimate = 0; /* signal for a major collection */ - else - g->GCestimate = estimate; /* keep estimate from last major coll. */ - + debt = (debt / STEPMULADJ) + 1; + debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM; + return debt; } - setpause(g, gettotalbytes(g)); - lua_assert(g->gcstate == GCSpropagate); } - -static void incstep (lua_State *L) { +/* +** performs a basic GC step when collector is running +*/ +void luaC_step (lua_State *L) { global_State *g = G(L); - l_mem debt = g->GCdebt; - int stepmul = g->gcstepmul; - if (stepmul < 40) stepmul = 40; /* avoid ridiculous low values (and 0) */ - /* convert debt from Kb to 'work units' (avoid zero debt and overflows) */ - debt = (debt / STEPMULADJ) + 1; - debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM; - do { /* always perform at least one single step */ - lu_mem work = singlestep(L); /* do some work */ + l_mem debt = getdebt(g); /* GC deficit (be paid now) */ + if (!g->gcrunning) { /* not running? */ + luaE_setdebt(g, -GCSTEPSIZE * 10); /* avoid being called too often */ + return; + } + do { /* repeat until pause or enough "credit" (negative debt) */ + lu_mem work = singlestep(L); /* perform one single step */ debt -= work; } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause); if (g->gcstate == GCSpause) - setpause(g, g->GCestimate); /* pause until next cycle */ + setpause(g); /* pause until next cycle */ else { - debt = (debt / stepmul) * STEPMULADJ; /* convert 'work units' to Kb */ + debt = (debt / g->gcstepmul) * STEPMULADJ; /* convert 'work units' to Kb */ luaE_setdebt(g, debt); + runafewfinalizers(L); } } /* -** performs a basic GC step -*/ -void luaC_forcestep (lua_State *L) { - global_State *g = G(L); - int i; - if (isgenerational(g)) generationalcollection(L); - else incstep(L); - /* run a few finalizers (or all of them at the end of a collect cycle) */ - for (i = 0; g->tobefnz && (i < GCFINALIZENUM || g->gcstate == GCSpause); i++) - GCTM(L, 1); /* call one finalizer */ -} - - -/* -** performs a basic GC step only if collector is running -*/ -void luaC_step (lua_State *L) { - global_State *g = G(L); - if (g->gcrunning) luaC_forcestep(L); - else luaE_setdebt(g, -GCSTEPSIZE); /* avoid being called too often */ -} - - - -/* -** performs a full GC cycle; if "isemergency", does not call -** finalizers (which could change stack positions) +** Performs a full GC cycle; if 'isemergency', set a flag to avoid +** some operations which could change the interpreter state in some +** unexpected ways (running finalizers and shrinking some structures). +** Before running the collection, check 'keepinvariant'; if it is true, +** there may be some objects marked as black, so the collector has +** to sweep all objects to turn them back to white (as white has not +** changed, nothing will be collected). */ void luaC_fullgc (lua_State *L, int isemergency) { global_State *g = G(L); - int origkind = g->gckind; - lua_assert(origkind != KGC_EMERGENCY); - if (isemergency) /* do not run finalizers during emergency GC */ - g->gckind = KGC_EMERGENCY; - else { - g->gckind = KGC_NORMAL; - callallpendingfinalizers(L, 1); - } - if (keepinvariant(g)) { /* may there be some black objects? */ - /* must sweep all objects to turn them back to white - (as white has not changed, nothing will be collected) */ - entersweep(L); + lua_assert(g->gckind == KGC_NORMAL); + if (isemergency) g->gckind = KGC_EMERGENCY; /* set flag */ + if (keepinvariant(g)) { /* black objects? */ + entersweep(L); /* sweep everything to turn them back to white */ } /* finish any pending sweep phase to start a new cycle */ luaC_runtilstate(L, bitmask(GCSpause)); luaC_runtilstate(L, ~bitmask(GCSpause)); /* start new collection */ - luaC_runtilstate(L, bitmask(GCSpause)); /* run entire collection */ - if (origkind == KGC_GEN) { /* generational mode? */ - /* generational mode must be kept in propagate phase */ - luaC_runtilstate(L, bitmask(GCSpropagate)); - } - g->gckind = origkind; - setpause(g, gettotalbytes(g)); - if (!isemergency) /* do not run finalizers during emergency GC */ - callallpendingfinalizers(L, 1); + luaC_runtilstate(L, bitmask(GCScallfin)); /* run up to finalizers */ + /* estimate must be correct after a full GC cycle */ + lua_assert(g->GCestimate == gettotalbytes(g)); + luaC_runtilstate(L, bitmask(GCSpause)); /* finish collection */ + g->gckind = KGC_NORMAL; + setpause(g); } /* }====================================================== */ diff --git a/depends/lua/src/linit.c b/depends/lua/src/linit.c index c1a3830471..480da52c7e 100644 --- a/depends/lua/src/linit.c +++ b/depends/lua/src/linit.c @@ -1,20 +1,33 @@ /* -** $Id: linit.c,v 1.32.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: linit.c,v 1.39.1.1 2017/04/19 17:20:42 roberto Exp $ ** Initialization of libraries for lua.c and other clients ** See Copyright Notice in lua.h */ +#define linit_c +#define LUA_LIB + /* ** If you embed Lua in your program and need to open the standard ** libraries, call luaL_openlibs in your program. If you need a ** different set of libraries, copy this file to your project and edit ** it to suit your needs. +** +** You can also *preload* libraries, so that a later 'require' can +** open the library, which is already linked to the application. +** For that, do the following code: +** +** luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE); +** lua_pushcfunction(L, luaopen_modname); +** lua_setfield(L, -2, modname); +** lua_pop(L, 1); // remove PRELOAD table */ +#include "lprefix.h" -#define linit_c -#define LUA_LIB + +#include #include "lua.h" @@ -34,34 +47,22 @@ static const luaL_Reg loadedlibs[] = { {LUA_IOLIBNAME, luaopen_io}, {LUA_OSLIBNAME, luaopen_os}, {LUA_STRLIBNAME, luaopen_string}, - {LUA_BITLIBNAME, luaopen_bit32}, {LUA_MATHLIBNAME, luaopen_math}, + {LUA_UTF8LIBNAME, luaopen_utf8}, {LUA_DBLIBNAME, luaopen_debug}, - {NULL, NULL} -}; - - -/* -** these libs are preloaded and must be required before used -*/ -static const luaL_Reg preloadedlibs[] = { +#if defined(LUA_COMPAT_BITLIB) + {LUA_BITLIBNAME, luaopen_bit32}, +#endif {NULL, NULL} }; LUALIB_API void luaL_openlibs (lua_State *L) { const luaL_Reg *lib; - /* call open functions from 'loadedlibs' and set results to global table */ + /* "require" functions from 'loadedlibs' and set results to global table */ for (lib = loadedlibs; lib->func; lib++) { luaL_requiref(L, lib->name, lib->func, 1); lua_pop(L, 1); /* remove lib */ } - /* add open functions from 'preloadedlibs' into 'package.preload' table */ - luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD"); - for (lib = preloadedlibs; lib->func; lib++) { - lua_pushcfunction(L, lib->func); - lua_setfield(L, -2, lib->name); - } - lua_pop(L, 1); /* remove _PRELOAD table */ } diff --git a/depends/lua/src/liolib.c b/depends/lua/src/liolib.c index 2a4ec4aa34..027d4bd0db 100644 --- a/depends/lua/src/liolib.c +++ b/depends/lua/src/liolib.c @@ -1,120 +1,140 @@ /* -** $Id: liolib.c,v 2.112.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: liolib.c,v 2.151.1.1 2017/04/19 17:29:57 roberto Exp $ ** Standard I/O (and system) library ** See Copyright Notice in lua.h */ +#define liolib_c +#define LUA_LIB -/* -** This definition must come before the inclusion of 'stdio.h'; it -** should not affect non-POSIX systems -*/ -#if !defined(_FILE_OFFSET_BITS) -#define _LARGEFILE_SOURCE 1 -#define _FILE_OFFSET_BITS 64 -#endif +#include "lprefix.h" +#include #include +#include #include #include #include -#define liolib_c -#define LUA_LIB - #include "lua.h" #include "lauxlib.h" #include "lualib.h" -#if !defined(lua_checkmode) + /* -** Check whether 'mode' matches '[rwa]%+?b?'. ** Change this macro to accept other modes for 'fopen' besides ** the standard ones. */ -#define lua_checkmode(mode) \ - (*mode != '\0' && strchr("rwa", *(mode++)) != NULL && \ - (*mode != '+' || ++mode) && /* skip if char is '+' */ \ - (*mode != 'b' || ++mode) && /* skip if char is 'b' */ \ - (*mode == '\0')) +#if !defined(l_checkmode) + +/* accepted extensions to 'mode' in 'fopen' */ +#if !defined(L_MODEEXT) +#define L_MODEEXT "b" +#endif + +/* Check whether 'mode' matches '[rwa]%+?[L_MODEEXT]*' */ +static int l_checkmode (const char *mode) { + return (*mode != '\0' && strchr("rwa", *(mode++)) != NULL && + (*mode != '+' || (++mode, 1)) && /* skip if char is '+' */ + (strspn(mode, L_MODEEXT) == strlen(mode))); /* check extensions */ +} #endif /* ** {====================================================== -** lua_popen spawns a new process connected to the current +** l_popen spawns a new process connected to the current ** one through the file streams. ** ======================================================= */ -#if !defined(lua_popen) /* { */ - -#if defined(LUA_USE_POPEN) /* { */ +#if !defined(l_popen) /* { */ -#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m)) -#define lua_pclose(L,file) ((void)L, pclose(file)) +#if defined(LUA_USE_POSIX) /* { */ -#elif defined(LUA_WIN) /* }{ */ +#define l_popen(L,c,m) (fflush(NULL), popen(c,m)) +#define l_pclose(L,file) (pclose(file)) -#define lua_popen(L,c,m) ((void)L, _popen(c,m)) -#define lua_pclose(L,file) ((void)L, _pclose(file)) +#elif defined(LUA_USE_WINDOWS) /* }{ */ +#define l_popen(L,c,m) (_popen(c,m)) +#define l_pclose(L,file) (_pclose(file)) #else /* }{ */ -#define lua_popen(L,c,m) ((void)((void)c, m), \ - luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0) -#define lua_pclose(L,file) ((void)((void)L, file), -1) - +/* ISO C definitions */ +#define l_popen(L,c,m) \ + ((void)((void)c, m), \ + luaL_error(L, "'popen' not supported"), \ + (FILE*)0) +#define l_pclose(L,file) ((void)L, (void)file, -1) #endif /* } */ -#endif /* } */ +#endif /* } */ /* }====================================================== */ +#if !defined(l_getc) /* { */ + +#if defined(LUA_USE_POSIX) +#define l_getc(f) getc_unlocked(f) +#define l_lockfile(f) flockfile(f) +#define l_unlockfile(f) funlockfile(f) +#else +#define l_getc(f) getc(f) +#define l_lockfile(f) ((void)0) +#define l_unlockfile(f) ((void)0) +#endif + +#endif /* } */ + + /* ** {====================================================== -** lua_fseek: configuration for longer offsets +** l_fseek: configuration for longer offsets ** ======================================================= */ -#if !defined(lua_fseek) && !defined(LUA_ANSI) /* { */ +#if !defined(l_fseek) /* { */ #if defined(LUA_USE_POSIX) /* { */ +#include + #define l_fseek(f,o,w) fseeko(f,o,w) #define l_ftell(f) ftello(f) #define l_seeknum off_t -#elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \ +#elif defined(LUA_USE_WINDOWS) && !defined(_CRTIMP_TYPEINFO) \ && defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */ -/* Windows (but not DDK) and Visual C++ 2005 or higher */ +/* Windows (but not DDK) and Visual C++ 2005 or higher */ #define l_fseek(f,o,w) _fseeki64(f,o,w) #define l_ftell(f) _ftelli64(f) #define l_seeknum __int64 -#endif /* } */ - -#endif /* } */ - +#else /* }{ */ -#if !defined(l_fseek) /* default definitions */ +/* ISO C definitions */ #define l_fseek(f,o,w) fseek(f,o,w) #define l_ftell(f) ftell(f) #define l_seeknum long -#endif + +#endif /* } */ + +#endif /* } */ /* }====================================================== */ #define IO_PREFIX "_IO_" +#define IOPREF_LEN (sizeof(IO_PREFIX)/sizeof(char) - 1) #define IO_INPUT (IO_PREFIX "input") #define IO_OUTPUT (IO_PREFIX "output") @@ -161,9 +181,9 @@ static FILE *tofile (lua_State *L) { /* -** When creating file handles, always creates a `closed' file handle +** When creating file handles, always creates a 'closed' file handle ** before opening the actual file; so, if there is a memory error, the -** file is not left opened. +** handle is in a consistent state. */ static LStream *newprefile (lua_State *L) { LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream)); @@ -173,19 +193,29 @@ static LStream *newprefile (lua_State *L) { } +/* +** Calls the 'close' function from a file handle. The 'volatile' avoids +** a bug in some versions of the Clang compiler (e.g., clang 3.0 for +** 32 bits). +*/ static int aux_close (lua_State *L) { LStream *p = tolstream(L); - lua_CFunction cf = p->closef; + volatile lua_CFunction cf = p->closef; p->closef = NULL; /* mark stream as closed */ return (*cf)(L); /* close it */ } +static int f_close (lua_State *L) { + tofile(L); /* make sure argument is an open stream */ + return aux_close(L); +} + + static int io_close (lua_State *L) { if (lua_isnone(L, 1)) /* no argument? */ lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT); /* use standard output */ - tofile(L); /* make sure argument is an open stream */ - return aux_close(L); + return f_close(L); } @@ -219,7 +249,7 @@ static void opencheck (lua_State *L, const char *fname, const char *mode) { LStream *p = newfile(L); p->f = fopen(fname, mode); if (p->f == NULL) - luaL_error(L, "cannot open file " LUA_QS " (%s)", fname, strerror(errno)); + luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno)); } @@ -228,7 +258,7 @@ static int io_open (lua_State *L) { const char *mode = luaL_optstring(L, 2, "r"); LStream *p = newfile(L); const char *md = mode; /* to traverse/check mode */ - luaL_argcheck(L, lua_checkmode(md), 2, "invalid mode"); + luaL_argcheck(L, l_checkmode(md), 2, "invalid mode"); p->f = fopen(filename, mode); return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1; } @@ -239,7 +269,7 @@ static int io_open (lua_State *L) { */ static int io_pclose (lua_State *L) { LStream *p = tolstream(L); - return luaL_execresult(L, lua_pclose(L, p->f)); + return luaL_execresult(L, l_pclose(L, p->f)); } @@ -247,7 +277,9 @@ static int io_popen (lua_State *L) { const char *filename = luaL_checkstring(L, 1); const char *mode = luaL_optstring(L, 2, "r"); LStream *p = newprefile(L); - p->f = lua_popen(L, filename, mode); + luaL_argcheck(L, ((mode[0] == 'r' || mode[0] == 'w') && mode[1] == '\0'), + 2, "invalid mode"); + p->f = l_popen(L, filename, mode); p->closef = &io_pclose; return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1; } @@ -265,7 +297,7 @@ static FILE *getiofile (lua_State *L, const char *findex) { lua_getfield(L, LUA_REGISTRYINDEX, findex); p = (LStream *)lua_touserdata(L, -1); if (isclosed(p)) - luaL_error(L, "standard %s file is closed", findex + strlen(IO_PREFIX)); + luaL_error(L, "standard %s file is closed", findex + IOPREF_LEN); return p->f; } @@ -300,15 +332,18 @@ static int io_output (lua_State *L) { static int io_readline (lua_State *L); +/* +** maximum number of arguments to 'f:lines'/'io.lines' (it + 3 must fit +** in the limit for upvalues of a closure) +*/ +#define MAXARGLINE 250 + static void aux_lines (lua_State *L, int toclose) { - int i; int n = lua_gettop(L) - 1; /* number of arguments to read */ - /* ensure that arguments will fit here and into 'io_readline' stack */ - luaL_argcheck(L, n <= LUA_MINSTACK - 3, LUA_MINSTACK - 3, "too many options"); - lua_pushvalue(L, 1); /* file handle */ + luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments"); lua_pushinteger(L, n); /* number of arguments to read */ lua_pushboolean(L, toclose); /* close/not close file when finished */ - for (i = 1; i <= n; i++) lua_pushvalue(L, i + 1); /* copy arguments */ + lua_rotate(L, 2, 2); /* move 'n' and 'toclose' to their positions */ lua_pushcclosure(L, io_readline, 3 + n); } @@ -347,13 +382,91 @@ static int io_lines (lua_State *L) { */ -static int read_number (lua_State *L, FILE *f) { - lua_Number d; - if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) { - lua_pushnumber(L, d); - return 1; +/* maximum length of a numeral */ +#if !defined (L_MAXLENNUM) +#define L_MAXLENNUM 200 +#endif + + +/* auxiliary structure used by 'read_number' */ +typedef struct { + FILE *f; /* file being read */ + int c; /* current character (look ahead) */ + int n; /* number of elements in buffer 'buff' */ + char buff[L_MAXLENNUM + 1]; /* +1 for ending '\0' */ +} RN; + + +/* +** Add current char to buffer (if not out of space) and read next one +*/ +static int nextc (RN *rn) { + if (rn->n >= L_MAXLENNUM) { /* buffer overflow? */ + rn->buff[0] = '\0'; /* invalidate result */ + return 0; /* fail */ } else { + rn->buff[rn->n++] = rn->c; /* save current char */ + rn->c = l_getc(rn->f); /* read next one */ + return 1; + } +} + + +/* +** Accept current char if it is in 'set' (of size 2) +*/ +static int test2 (RN *rn, const char *set) { + if (rn->c == set[0] || rn->c == set[1]) + return nextc(rn); + else return 0; +} + + +/* +** Read a sequence of (hex)digits +*/ +static int readdigits (RN *rn, int hex) { + int count = 0; + while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn)) + count++; + return count; +} + + +/* +** Read a number: first reads a valid prefix of a numeral into a buffer. +** Then it calls 'lua_stringtonumber' to check whether the format is +** correct and to convert it to a Lua number +*/ +static int read_number (lua_State *L, FILE *f) { + RN rn; + int count = 0; + int hex = 0; + char decp[2]; + rn.f = f; rn.n = 0; + decp[0] = lua_getlocaledecpoint(); /* get decimal point from locale */ + decp[1] = '.'; /* always accept a dot */ + l_lockfile(rn.f); + do { rn.c = l_getc(rn.f); } while (isspace(rn.c)); /* skip spaces */ + test2(&rn, "-+"); /* optional signal */ + if (test2(&rn, "00")) { + if (test2(&rn, "xX")) hex = 1; /* numeral is hexadecimal */ + else count = 1; /* count initial '0' as a valid digit */ + } + count += readdigits(&rn, hex); /* integral part */ + if (test2(&rn, decp)) /* decimal point? */ + count += readdigits(&rn, hex); /* fractional part */ + if (count > 0 && test2(&rn, (hex ? "pP" : "eE"))) { /* exponent mark? */ + test2(&rn, "-+"); /* exponent signal */ + readdigits(&rn, 0); /* exponent digits */ + } + ungetc(rn.c, rn.f); /* unread look-ahead char */ + l_unlockfile(rn.f); + rn.buff[rn.n] = '\0'; /* finish string */ + if (lua_stringtonumber(L, rn.buff)) /* is this a valid number? */ + return 1; /* ok */ + else { /* invalid format */ lua_pushnil(L); /* "result" to be removed */ return 0; /* read fails */ } @@ -362,48 +475,42 @@ static int read_number (lua_State *L, FILE *f) { static int test_eof (lua_State *L, FILE *f) { int c = getc(f); - ungetc(c, f); - lua_pushlstring(L, NULL, 0); + ungetc(c, f); /* no-op when c == EOF */ + lua_pushliteral(L, ""); return (c != EOF); } static int read_line (lua_State *L, FILE *f, int chop) { luaL_Buffer b; + int c = '\0'; luaL_buffinit(L, &b); - for (;;) { - size_t l; - char *p = luaL_prepbuffer(&b); - if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */ - luaL_pushresult(&b); /* close buffer */ - return (lua_rawlen(L, -1) > 0); /* check whether read something */ - } - l = strlen(p); - if (l == 0 || p[l-1] != '\n') - luaL_addsize(&b, l); - else { - luaL_addsize(&b, l - chop); /* chop 'eol' if needed */ - luaL_pushresult(&b); /* close buffer */ - return 1; /* read at least an `eol' */ - } + while (c != EOF && c != '\n') { /* repeat until end of line */ + char *buff = luaL_prepbuffer(&b); /* preallocate buffer */ + int i = 0; + l_lockfile(f); /* no memory errors can happen inside the lock */ + while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n') + buff[i++] = c; + l_unlockfile(f); + luaL_addsize(&b, i); } + if (!chop && c == '\n') /* want a newline and have one? */ + luaL_addchar(&b, c); /* add ending newline to result */ + luaL_pushresult(&b); /* close buffer */ + /* return ok if read something (either a newline or something else) */ + return (c == '\n' || lua_rawlen(L, -1) > 0); } -#define MAX_SIZE_T (~(size_t)0) - static void read_all (lua_State *L, FILE *f) { - size_t rlen = LUAL_BUFFERSIZE; /* how much to read in each cycle */ + size_t nr; luaL_Buffer b; luaL_buffinit(L, &b); - for (;;) { - char *p = luaL_prepbuffsize(&b, rlen); - size_t nr = fread(p, sizeof(char), rlen, f); + do { /* read file in chunks of LUAL_BUFFERSIZE bytes */ + char *p = luaL_prepbuffer(&b); + nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f); luaL_addsize(&b, nr); - if (nr < rlen) break; /* eof? */ - else if (rlen <= (MAX_SIZE_T / 4)) /* avoid buffers too large */ - rlen *= 2; /* double buffer size at each iteration */ - } + } while (nr == LUAL_BUFFERSIZE); luaL_pushresult(&b); /* close buffer */ } @@ -435,13 +542,13 @@ static int g_read (lua_State *L, FILE *f, int first) { success = 1; for (n = first; nargs-- && success; n++) { if (lua_type(L, n) == LUA_TNUMBER) { - size_t l = (size_t)lua_tointeger(L, n); + size_t l = (size_t)luaL_checkinteger(L, n); success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l); } else { - const char *p = lua_tostring(L, n); - luaL_argcheck(L, p && p[0] == '*', n, "invalid option"); - switch (p[1]) { + const char *p = luaL_checkstring(L, n); + if (*p == '*') p++; /* skip optional '*' (for compatibility) */ + switch (*p) { case 'n': /* number */ success = read_number(L, f); break; @@ -488,11 +595,12 @@ static int io_readline (lua_State *L) { if (isclosed(p)) /* file is already closed? */ return luaL_error(L, "file is already closed"); lua_settop(L , 1); + luaL_checkstack(L, n, "too many arguments"); for (i = 1; i <= n; i++) /* push arguments to 'g_read' */ lua_pushvalue(L, lua_upvalueindex(3 + i)); n = g_read(L, p->f, 2); /* 'n' is number of results */ lua_assert(n > 0); /* should return at least a nil */ - if (!lua_isnil(L, -n)) /* read at least one value? */ + if (lua_toboolean(L, -n)) /* read at least one value? */ return n; /* return them */ else { /* first result is nil: EOF or error */ if (n > 1) { /* is there error information? */ @@ -517,8 +625,12 @@ static int g_write (lua_State *L, FILE *f, int arg) { for (; nargs--; arg++) { if (lua_type(L, arg) == LUA_TNUMBER) { /* optimization: could be done exactly as for strings */ - status = status && - fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0; + int len = lua_isinteger(L, arg) + ? fprintf(f, LUA_INTEGER_FMT, + (LUAI_UACINT)lua_tointeger(L, arg)) + : fprintf(f, LUA_NUMBER_FMT, + (LUAI_UACNUMBER)lua_tonumber(L, arg)); + status = status && (len > 0); } else { size_t l; @@ -548,15 +660,15 @@ static int f_seek (lua_State *L) { static const char *const modenames[] = {"set", "cur", "end", NULL}; FILE *f = tofile(L); int op = luaL_checkoption(L, 2, "cur", modenames); - lua_Number p3 = luaL_optnumber(L, 3, 0); + lua_Integer p3 = luaL_optinteger(L, 3, 0); l_seeknum offset = (l_seeknum)p3; - luaL_argcheck(L, (lua_Number)offset == p3, 3, + luaL_argcheck(L, (lua_Integer)offset == p3, 3, "not an integer in proper range"); op = l_fseek(f, offset, mode[op]); if (op) return luaL_fileresult(L, 0, NULL); /* error */ else { - lua_pushnumber(L, (lua_Number)l_ftell(f)); + lua_pushinteger(L, (lua_Integer)l_ftell(f)); return 1; } } @@ -568,7 +680,7 @@ static int f_setvbuf (lua_State *L) { FILE *f = tofile(L); int op = luaL_checkoption(L, 2, NULL, modenames); lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE); - int res = setvbuf(f, NULL, mode[op], sz); + int res = setvbuf(f, NULL, mode[op], (size_t)sz); return luaL_fileresult(L, res == 0, NULL); } @@ -607,7 +719,7 @@ static const luaL_Reg iolib[] = { ** methods for file handles */ static const luaL_Reg flib[] = { - {"close", io_close}, + {"close", f_close}, {"flush", f_flush}, {"lines", f_lines}, {"read", f_read}, diff --git a/depends/lua/src/llex.c b/depends/lua/src/llex.c index c4b820e833..b6d9a465fe 100644 --- a/depends/lua/src/llex.c +++ b/depends/lua/src/llex.c @@ -1,20 +1,24 @@ /* -** $Id: llex.c,v 2.63.1.2 2013/08/30 15:49:41 roberto Exp $ +** $Id: llex.c,v 2.96.1.1 2017/04/19 17:20:42 roberto Exp $ ** Lexical Analyzer ** See Copyright Notice in lua.h */ +#define llex_c +#define LUA_CORE + +#include "lprefix.h" + #include #include -#define llex_c -#define LUA_CORE - #include "lua.h" #include "lctype.h" +#include "ldebug.h" #include "ldo.h" +#include "lgc.h" #include "llex.h" #include "lobject.h" #include "lparser.h" @@ -38,8 +42,9 @@ static const char *const luaX_tokens [] = { "end", "false", "for", "function", "goto", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while", - "..", "...", "==", ">=", "<=", "~=", "::", "", - "", "", "" + "//", "..", "...", "==", ">=", "<=", "~=", + "<<", ">>", "::", "", + "", "", "", "" }; @@ -53,7 +58,7 @@ static void save (LexState *ls, int c) { Mbuffer *b = ls->buff; if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { size_t newsize; - if (luaZ_sizebuffer(b) >= MAX_SIZET/2) + if (luaZ_sizebuffer(b) >= MAX_SIZE/2) lexerror(ls, "lexical element too long", 0); newsize = luaZ_sizebuffer(b) * 2; luaZ_resizebuffer(ls->L, b, newsize); @@ -64,24 +69,25 @@ static void save (LexState *ls, int c) { void luaX_init (lua_State *L) { int i; + TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */ + luaC_fix(L, obj2gco(e)); /* never collect this name */ for (i=0; itsv.extra = cast_byte(i+1); /* reserved word */ + luaC_fix(L, obj2gco(ts)); /* reserved words are never collected */ + ts->extra = cast_byte(i+1); /* reserved word */ } } const char *luaX_token2str (LexState *ls, int token) { if (token < FIRST_RESERVED) { /* single-byte symbols? */ - lua_assert(token == cast(unsigned char, token)); - return (lisprint(token)) ? luaO_pushfstring(ls->L, LUA_QL("%c"), token) : - luaO_pushfstring(ls->L, "char(%d)", token); + lua_assert(token == cast_uchar(token)); + return luaO_pushfstring(ls->L, "'%c'", token); } else { const char *s = luaX_tokens[token - FIRST_RESERVED]; if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ - return luaO_pushfstring(ls->L, LUA_QS, s); + return luaO_pushfstring(ls->L, "'%s'", s); else /* names, strings, and numerals */ return s; } @@ -90,11 +96,10 @@ const char *luaX_token2str (LexState *ls, int token) { static const char *txtToken (LexState *ls, int token) { switch (token) { - case TK_NAME: - case TK_STRING: - case TK_NUMBER: + case TK_NAME: case TK_STRING: + case TK_FLT: case TK_INT: save(ls, '\0'); - return luaO_pushfstring(ls->L, LUA_QS, luaZ_buffer(ls->buff)); + return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff)); default: return luaX_token2str(ls, token); } @@ -102,9 +107,7 @@ static const char *txtToken (LexState *ls, int token) { static l_noret lexerror (LexState *ls, const char *msg, int token) { - char buff[LUA_IDSIZE]; - luaO_chunkid(buff, getstr(ls->source), LUA_IDSIZE); - msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg); + msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber); if (token) luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); luaD_throw(ls->L, LUA_ERRSYNTAX); @@ -117,24 +120,24 @@ l_noret luaX_syntaxerror (LexState *ls, const char *msg) { /* -** creates a new string and anchors it in function's table so that -** it will not be collected until the end of the function's compilation -** (by that time it should be anchored in function's prototype) +** creates a new string and anchors it in scanner's table so that +** it will not be collected until the end of the compilation +** (by that time it should be anchored somewhere) */ TString *luaX_newstring (LexState *ls, const char *str, size_t l) { lua_State *L = ls->L; - TValue *o; /* entry for `str' */ + TValue *o; /* entry for 'str' */ TString *ts = luaS_newlstr(L, str, l); /* create new string */ setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */ - o = luaH_set(L, ls->fs->h, L->top - 1); - if (ttisnil(o)) { /* not in use yet? (see 'addK') */ + o = luaH_set(L, ls->h, L->top - 1); + if (ttisnil(o)) { /* not in use yet? */ /* boolean value does not need GC barrier; table has no metatable, so it does not need to invalidate cache */ setbvalue(o, 1); /* t[string] = true */ luaC_checkGC(L); } else { /* string already present */ - ts = rawtsvalue(keyfromval(o)); /* re-use value previously stored */ + ts = tsvalue(keyfromval(o)); /* re-use value previously stored */ } L->top--; /* remove string from stack */ return ts; @@ -148,17 +151,17 @@ TString *luaX_newstring (LexState *ls, const char *str, size_t l) { static void inclinenumber (LexState *ls) { int old = ls->current; lua_assert(currIsNewline(ls)); - next(ls); /* skip `\n' or `\r' */ + next(ls); /* skip '\n' or '\r' */ if (currIsNewline(ls) && ls->current != old) - next(ls); /* skip `\n\r' or `\r\n' */ + next(ls); /* skip '\n\r' or '\r\n' */ if (++ls->linenumber >= MAX_INT) - luaX_syntaxerror(ls, "chunk has too many lines"); + lexerror(ls, "chunk has too many lines", 0); } void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source, int firstchar) { - ls->decpoint = '.'; + ls->t.token = 0; ls->L = L; ls->current = firstchar; ls->lookahead.token = TK_EOS; /* no look-ahead token */ @@ -167,8 +170,7 @@ void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source, ls->linenumber = 1; ls->lastline = 1; ls->source = source; - ls->envn = luaS_new(L, LUA_ENV); /* create env name */ - luaS_fix(ls->envn); /* never collect this name */ + ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */ luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ } @@ -181,81 +183,73 @@ void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source, */ - -static int check_next (LexState *ls, const char *set) { - if (ls->current == '\0' || !strchr(set, ls->current)) - return 0; - save_and_next(ls); - return 1; -} - - -/* -** change all characters 'from' in buffer to 'to' -*/ -static void buffreplace (LexState *ls, char from, char to) { - size_t n = luaZ_bufflen(ls->buff); - char *p = luaZ_buffer(ls->buff); - while (n--) - if (p[n] == from) p[n] = to; +static int check_next1 (LexState *ls, int c) { + if (ls->current == c) { + next(ls); + return 1; + } + else return 0; } -#if !defined(getlocaledecpoint) -#define getlocaledecpoint() (localeconv()->decimal_point[0]) -#endif - - -#define buff2d(b,e) luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e) - /* -** in case of format error, try to change decimal point separator to -** the one defined in the current locale and check again +** Check whether current char is in set 'set' (with two chars) and +** saves it */ -static void trydecpoint (LexState *ls, SemInfo *seminfo) { - char old = ls->decpoint; - ls->decpoint = getlocaledecpoint(); - buffreplace(ls, old, ls->decpoint); /* try new decimal separator */ - if (!buff2d(ls->buff, &seminfo->r)) { - /* format error with correct decimal point: no more options */ - buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */ - lexerror(ls, "malformed number", TK_NUMBER); +static int check_next2 (LexState *ls, const char *set) { + lua_assert(set[2] == '\0'); + if (ls->current == set[0] || ls->current == set[1]) { + save_and_next(ls); + return 1; } + else return 0; } /* LUA_NUMBER */ /* -** this function is quite liberal in what it accepts, as 'luaO_str2d' +** this function is quite liberal in what it accepts, as 'luaO_str2num' ** will reject ill-formed numerals. */ -static void read_numeral (LexState *ls, SemInfo *seminfo) { +static int read_numeral (LexState *ls, SemInfo *seminfo) { + TValue obj; const char *expo = "Ee"; int first = ls->current; lua_assert(lisdigit(ls->current)); save_and_next(ls); - if (first == '0' && check_next(ls, "Xx")) /* hexadecimal? */ + if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */ expo = "Pp"; for (;;) { - if (check_next(ls, expo)) /* exponent part? */ - check_next(ls, "+-"); /* optional exponent sign */ - if (lisxdigit(ls->current) || ls->current == '.') + if (check_next2(ls, expo)) /* exponent part? */ + check_next2(ls, "-+"); /* optional exponent sign */ + if (lisxdigit(ls->current)) + save_and_next(ls); + else if (ls->current == '.') save_and_next(ls); - else break; + else break; } save(ls, '\0'); - buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */ - if (!buff2d(ls->buff, &seminfo->r)) /* format error? */ - trydecpoint(ls, seminfo); /* try to update decimal point separator */ + if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */ + lexerror(ls, "malformed number", TK_FLT); + if (ttisinteger(&obj)) { + seminfo->i = ivalue(&obj); + return TK_INT; + } + else { + lua_assert(ttisfloat(&obj)); + seminfo->r = fltvalue(&obj); + return TK_FLT; + } } /* -** skip a sequence '[=*[' or ']=*]' and return its number of '='s or -** -1 if sequence is malformed +** reads a sequence '[=*[' or ']=*]', leaving the last bracket. +** If sequence is well formed, return its number of '='s + 2; otherwise, +** return 1 if there is no '='s or 0 otherwise (an unfinished '[==...'). */ -static int skip_sep (LexState *ls) { - int count = 0; +static size_t skip_sep (LexState *ls) { + size_t count = 0; int s = ls->current; lua_assert(s == '[' || s == ']'); save_and_next(ls); @@ -263,23 +257,30 @@ static int skip_sep (LexState *ls) { save_and_next(ls); count++; } - return (ls->current == s) ? count : (-count) - 1; + return (ls->current == s) ? count + 2 + : (count == 0) ? 1 + : 0; + } -static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) { - save_and_next(ls); /* skip 2nd `[' */ +static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) { + int line = ls->linenumber; /* initial line (for error message) */ + save_and_next(ls); /* skip 2nd '[' */ if (currIsNewline(ls)) /* string starts with a newline? */ inclinenumber(ls); /* skip it */ for (;;) { switch (ls->current) { - case EOZ: - lexerror(ls, (seminfo) ? "unfinished long string" : - "unfinished long comment", TK_EOS); + case EOZ: { /* error */ + const char *what = (seminfo ? "string" : "comment"); + const char *msg = luaO_pushfstring(ls->L, + "unfinished long %s (starting at line %d)", what, line); + lexerror(ls, msg, TK_EOS); break; /* to avoid warnings */ + } case ']': { if (skip_sep(ls) == sep) { - save_and_next(ls); /* skip 2nd `]' */ + save_and_next(ls); /* skip 2nd ']' */ goto endloop; } break; @@ -297,45 +298,70 @@ static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) { } } endloop: if (seminfo) - seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep), - luaZ_bufflen(ls->buff) - 2*(2 + sep)); + seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep, + luaZ_bufflen(ls->buff) - 2 * sep); } -static void escerror (LexState *ls, int *c, int n, const char *msg) { - int i; - luaZ_resetbuffer(ls->buff); /* prepare error message */ - save(ls, '\\'); - for (i = 0; i < n && c[i] != EOZ; i++) - save(ls, c[i]); - lexerror(ls, msg, TK_STRING); +static void esccheck (LexState *ls, int c, const char *msg) { + if (!c) { + if (ls->current != EOZ) + save_and_next(ls); /* add current to buffer for error message */ + lexerror(ls, msg, TK_STRING); + } +} + + +static int gethexa (LexState *ls) { + save_and_next(ls); + esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected"); + return luaO_hexavalue(ls->current); } static int readhexaesc (LexState *ls) { - int c[3], i; /* keep input for error message */ - int r = 0; /* result accumulator */ - c[0] = 'x'; /* for error message */ - for (i = 1; i < 3; i++) { /* read two hexadecimal digits */ - c[i] = next(ls); - if (!lisxdigit(c[i])) - escerror(ls, c, i + 1, "hexadecimal digit expected"); - r = (r << 4) + luaO_hexavalue(c[i]); + int r = gethexa(ls); + r = (r << 4) + gethexa(ls); + luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */ + return r; +} + + +static unsigned long readutf8esc (LexState *ls) { + unsigned long r; + int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */ + save_and_next(ls); /* skip 'u' */ + esccheck(ls, ls->current == '{', "missing '{'"); + r = gethexa(ls); /* must have at least one digit */ + while ((save_and_next(ls), lisxdigit(ls->current))) { + i++; + r = (r << 4) + luaO_hexavalue(ls->current); + esccheck(ls, r <= 0x10FFFF, "UTF-8 value too large"); } + esccheck(ls, ls->current == '}', "missing '}'"); + next(ls); /* skip '}' */ + luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */ return r; } +static void utf8esc (LexState *ls) { + char buff[UTF8BUFFSZ]; + int n = luaO_utf8esc(buff, readutf8esc(ls)); + for (; n > 0; n--) /* add 'buff' to string */ + save(ls, buff[UTF8BUFFSZ - n]); +} + + static int readdecesc (LexState *ls) { - int c[3], i; + int i; int r = 0; /* result accumulator */ for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */ - c[i] = ls->current; - r = 10*r + c[i] - '0'; - next(ls); + r = 10*r + ls->current - '0'; + save_and_next(ls); } - if (r > UCHAR_MAX) - escerror(ls, c, i, "decimal escape too large"); + esccheck(ls, r <= UCHAR_MAX, "decimal escape too large"); + luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */ return r; } @@ -353,7 +379,7 @@ static void read_string (LexState *ls, int del, SemInfo *seminfo) { break; /* to avoid warnings */ case '\\': { /* escape sequences */ int c; /* final character to be saved */ - next(ls); /* do not save the `\' */ + save_and_next(ls); /* keep '\\' for error messages */ switch (ls->current) { case 'a': c = '\a'; goto read_save; case 'b': c = '\b'; goto read_save; @@ -363,12 +389,14 @@ static void read_string (LexState *ls, int del, SemInfo *seminfo) { case 't': c = '\t'; goto read_save; case 'v': c = '\v'; goto read_save; case 'x': c = readhexaesc(ls); goto read_save; + case 'u': utf8esc(ls); goto no_save; case '\n': case '\r': inclinenumber(ls); c = '\n'; goto only_save; case '\\': case '\"': case '\'': c = ls->current; goto read_save; case EOZ: goto no_save; /* will raise an error next loop */ case 'z': { /* zap following span of spaces */ + luaZ_buffremove(ls->buff, 1); /* remove '\\' */ next(ls); /* skip the 'z' */ while (lisspace(ls->current)) { if (currIsNewline(ls)) inclinenumber(ls); @@ -377,15 +405,18 @@ static void read_string (LexState *ls, int del, SemInfo *seminfo) { goto no_save; } default: { - if (!lisdigit(ls->current)) - escerror(ls, &ls->current, 1, "invalid escape sequence"); - /* digital escape \ddd */ - c = readdecesc(ls); + esccheck(ls, lisdigit(ls->current), "invalid escape sequence"); + c = readdecesc(ls); /* digital escape '\ddd' */ goto only_save; } } - read_save: next(ls); /* read next character */ - only_save: save(ls, c); /* save 'c' */ + read_save: + next(ls); + /* go through */ + only_save: + luaZ_buffremove(ls->buff, 1); /* remove '\\' */ + save(ls, c); + /* go through */ no_save: break; } default: @@ -416,9 +447,9 @@ static int llex (LexState *ls, SemInfo *seminfo) { /* else is a comment */ next(ls); if (ls->current == '[') { /* long comment? */ - int sep = skip_sep(ls); - luaZ_resetbuffer(ls->buff); /* `skip_sep' may dirty the buffer */ - if (sep >= 0) { + size_t sep = skip_sep(ls); + luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */ + if (sep >= 2) { read_long_string(ls, NULL, sep); /* skip long comment */ luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */ break; @@ -430,38 +461,46 @@ static int llex (LexState *ls, SemInfo *seminfo) { break; } case '[': { /* long string or simply '[' */ - int sep = skip_sep(ls); - if (sep >= 0) { + size_t sep = skip_sep(ls); + if (sep >= 2) { read_long_string(ls, seminfo, sep); return TK_STRING; } - else if (sep == -1) return '['; - else lexerror(ls, "invalid long string delimiter", TK_STRING); + else if (sep == 0) /* '[=...' missing second bracket */ + lexerror(ls, "invalid long string delimiter", TK_STRING); + return '['; } case '=': { next(ls); - if (ls->current != '=') return '='; - else { next(ls); return TK_EQ; } + if (check_next1(ls, '=')) return TK_EQ; + else return '='; } case '<': { next(ls); - if (ls->current != '=') return '<'; - else { next(ls); return TK_LE; } + if (check_next1(ls, '=')) return TK_LE; + else if (check_next1(ls, '<')) return TK_SHL; + else return '<'; } case '>': { next(ls); - if (ls->current != '=') return '>'; - else { next(ls); return TK_GE; } + if (check_next1(ls, '=')) return TK_GE; + else if (check_next1(ls, '>')) return TK_SHR; + else return '>'; + } + case '/': { + next(ls); + if (check_next1(ls, '/')) return TK_IDIV; + else return '/'; } case '~': { next(ls); - if (ls->current != '=') return '~'; - else { next(ls); return TK_NE; } + if (check_next1(ls, '=')) return TK_NE; + else return '~'; } case ':': { next(ls); - if (ls->current != ':') return ':'; - else { next(ls); return TK_DBCOLON; } + if (check_next1(ls, ':')) return TK_DBCOLON; + else return ':'; } case '"': case '\'': { /* short literal strings */ read_string(ls, ls->current, seminfo); @@ -469,18 +508,17 @@ static int llex (LexState *ls, SemInfo *seminfo) { } case '.': { /* '.', '..', '...', or number */ save_and_next(ls); - if (check_next(ls, ".")) { - if (check_next(ls, ".")) + if (check_next1(ls, '.')) { + if (check_next1(ls, '.')) return TK_DOTS; /* '...' */ else return TK_CONCAT; /* '..' */ } else if (!lisdigit(ls->current)) return '.'; - /* else go through */ + else return read_numeral(ls, seminfo); } case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { - read_numeral(ls, seminfo); - return TK_NUMBER; + return read_numeral(ls, seminfo); } case EOZ: { return TK_EOS; @@ -495,7 +533,7 @@ static int llex (LexState *ls, SemInfo *seminfo) { luaZ_bufflen(ls->buff)); seminfo->ts = ts; if (isreserved(ts)) /* reserved word? */ - return ts->tsv.extra - 1 + FIRST_RESERVED; + return ts->extra - 1 + FIRST_RESERVED; else { return TK_NAME; } diff --git a/depends/lua/src/lmathlib.c b/depends/lua/src/lmathlib.c index fe9fc5423d..7ef7e593fd 100644 --- a/depends/lua/src/lmathlib.c +++ b/depends/lua/src/lmathlib.c @@ -1,16 +1,18 @@ /* -** $Id: lmathlib.c,v 1.83.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lmathlib.c,v 1.119.1.1 2017/04/19 17:20:42 roberto Exp $ ** Standard mathematical library ** See Copyright Notice in lua.h */ +#define lmathlib_c +#define LUA_LIB + +#include "lprefix.h" + #include #include -#define lmathlib_c -#define LUA_LIB - #include "lua.h" #include "lauxlib.h" @@ -18,13 +20,30 @@ #undef PI -#define PI ((lua_Number)(3.1415926535897932384626433832795)) -#define RADIANS_PER_DEGREE ((lua_Number)(PI/180.0)) - +#define PI (l_mathop(3.141592653589793238462643383279502884)) + + +#if !defined(l_rand) /* { */ +#if defined(LUA_USE_POSIX) +#define l_rand() random() +#define l_srand(x) srandom(x) +#define L_RANDMAX 2147483647 /* (2^31 - 1), following POSIX */ +#else +#define l_rand() rand() +#define l_srand(x) srand(x) +#define L_RANDMAX RAND_MAX +#endif +#endif /* } */ static int math_abs (lua_State *L) { - lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1))); + if (lua_isinteger(L, 1)) { + lua_Integer n = lua_tointeger(L, 1); + if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n); + lua_pushinteger(L, n); + } + else + lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1))); return 1; } @@ -33,31 +52,16 @@ static int math_sin (lua_State *L) { return 1; } -static int math_sinh (lua_State *L) { - lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1))); - return 1; -} - static int math_cos (lua_State *L) { lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1))); return 1; } -static int math_cosh (lua_State *L) { - lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1))); - return 1; -} - static int math_tan (lua_State *L) { lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1))); return 1; } -static int math_tanh (lua_State *L) { - lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1))); - return 1; -} - static int math_asin (lua_State *L) { lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1))); return 1; @@ -69,49 +73,106 @@ static int math_acos (lua_State *L) { } static int math_atan (lua_State *L) { - lua_pushnumber(L, l_mathop(atan)(luaL_checknumber(L, 1))); + lua_Number y = luaL_checknumber(L, 1); + lua_Number x = luaL_optnumber(L, 2, 1); + lua_pushnumber(L, l_mathop(atan2)(y, x)); return 1; } -static int math_atan2 (lua_State *L) { - lua_pushnumber(L, l_mathop(atan2)(luaL_checknumber(L, 1), - luaL_checknumber(L, 2))); + +static int math_toint (lua_State *L) { + int valid; + lua_Integer n = lua_tointegerx(L, 1, &valid); + if (valid) + lua_pushinteger(L, n); + else { + luaL_checkany(L, 1); + lua_pushnil(L); /* value is not convertible to integer */ + } return 1; } -static int math_ceil (lua_State *L) { - lua_pushnumber(L, l_mathop(ceil)(luaL_checknumber(L, 1))); - return 1; + +static void pushnumint (lua_State *L, lua_Number d) { + lua_Integer n; + if (lua_numbertointeger(d, &n)) /* does 'd' fit in an integer? */ + lua_pushinteger(L, n); /* result is integer */ + else + lua_pushnumber(L, d); /* result is float */ } + static int math_floor (lua_State *L) { - lua_pushnumber(L, l_mathop(floor)(luaL_checknumber(L, 1))); + if (lua_isinteger(L, 1)) + lua_settop(L, 1); /* integer is its own floor */ + else { + lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1)); + pushnumint(L, d); + } + return 1; +} + + +static int math_ceil (lua_State *L) { + if (lua_isinteger(L, 1)) + lua_settop(L, 1); /* integer is its own ceil */ + else { + lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1)); + pushnumint(L, d); + } return 1; } + static int math_fmod (lua_State *L) { - lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1), - luaL_checknumber(L, 2))); + if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) { + lua_Integer d = lua_tointeger(L, 2); + if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */ + luaL_argcheck(L, d != 0, 2, "zero"); + lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */ + } + else + lua_pushinteger(L, lua_tointeger(L, 1) % d); + } + else + lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1), + luaL_checknumber(L, 2))); return 1; } + +/* +** next function does not use 'modf', avoiding problems with 'double*' +** (which is not compatible with 'float*') when lua_Number is not +** 'double'. +*/ static int math_modf (lua_State *L) { - lua_Number ip; - lua_Number fp = l_mathop(modf)(luaL_checknumber(L, 1), &ip); - lua_pushnumber(L, ip); - lua_pushnumber(L, fp); + if (lua_isinteger(L ,1)) { + lua_settop(L, 1); /* number is its own integer part */ + lua_pushnumber(L, 0); /* no fractional part */ + } + else { + lua_Number n = luaL_checknumber(L, 1); + /* integer part (rounds toward zero) */ + lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n); + pushnumint(L, ip); + /* fractional part (test needed for inf/-inf) */ + lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip)); + } return 2; } + static int math_sqrt (lua_State *L) { lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1))); return 1; } -static int math_pow (lua_State *L) { - lua_Number x = luaL_checknumber(L, 1); - lua_Number y = luaL_checknumber(L, 2); - lua_pushnumber(L, l_mathop(pow)(x, y)); + +static int math_ult (lua_State *L) { + lua_Integer a = luaL_checkinteger(L, 1); + lua_Integer b = luaL_checkinteger(L, 2); + lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b); return 1; } @@ -122,145 +183,211 @@ static int math_log (lua_State *L) { res = l_mathop(log)(x); else { lua_Number base = luaL_checknumber(L, 2); - if (base == (lua_Number)10.0) res = l_mathop(log10)(x); - else res = l_mathop(log)(x)/l_mathop(log)(base); +#if !defined(LUA_USE_C89) + if (base == l_mathop(2.0)) + res = l_mathop(log2)(x); else +#endif + if (base == l_mathop(10.0)) + res = l_mathop(log10)(x); + else + res = l_mathop(log)(x)/l_mathop(log)(base); } lua_pushnumber(L, res); return 1; } -#if defined(LUA_COMPAT_LOG10) -static int math_log10 (lua_State *L) { - lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1))); - return 1; -} -#endif - static int math_exp (lua_State *L) { lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1))); return 1; } static int math_deg (lua_State *L) { - lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE); + lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI)); return 1; } static int math_rad (lua_State *L) { - lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE); - return 1; -} - -static int math_frexp (lua_State *L) { - int e; - lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e)); - lua_pushinteger(L, e); - return 2; -} - -static int math_ldexp (lua_State *L) { - lua_Number x = luaL_checknumber(L, 1); - int ep = luaL_checkint(L, 2); - lua_pushnumber(L, l_mathop(ldexp)(x, ep)); + lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0))); return 1; } - static int math_min (lua_State *L) { int n = lua_gettop(L); /* number of arguments */ - lua_Number dmin = luaL_checknumber(L, 1); + int imin = 1; /* index of current minimum value */ int i; - for (i=2; i<=n; i++) { - lua_Number d = luaL_checknumber(L, i); - if (d < dmin) - dmin = d; + luaL_argcheck(L, n >= 1, 1, "value expected"); + for (i = 2; i <= n; i++) { + if (lua_compare(L, i, imin, LUA_OPLT)) + imin = i; } - lua_pushnumber(L, dmin); + lua_pushvalue(L, imin); return 1; } static int math_max (lua_State *L) { int n = lua_gettop(L); /* number of arguments */ - lua_Number dmax = luaL_checknumber(L, 1); + int imax = 1; /* index of current maximum value */ int i; - for (i=2; i<=n; i++) { - lua_Number d = luaL_checknumber(L, i); - if (d > dmax) - dmax = d; + luaL_argcheck(L, n >= 1, 1, "value expected"); + for (i = 2; i <= n; i++) { + if (lua_compare(L, imax, i, LUA_OPLT)) + imax = i; } - lua_pushnumber(L, dmax); + lua_pushvalue(L, imax); return 1; } - +/* +** This function uses 'double' (instead of 'lua_Number') to ensure that +** all bits from 'l_rand' can be represented, and that 'RANDMAX + 1.0' +** will keep full precision (ensuring that 'r' is always less than 1.0.) +*/ static int math_random (lua_State *L) { - /* the `%' avoids the (rare) case of r==1, and is needed also because on - some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */ - lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX; + lua_Integer low, up; + double r = (double)l_rand() * (1.0 / ((double)L_RANDMAX + 1.0)); switch (lua_gettop(L)) { /* check number of arguments */ case 0: { /* no arguments */ - lua_pushnumber(L, r); /* Number between 0 and 1 */ - break; + lua_pushnumber(L, (lua_Number)r); /* Number between 0 and 1 */ + return 1; } case 1: { /* only upper limit */ - lua_Number u = luaL_checknumber(L, 1); - luaL_argcheck(L, (lua_Number)1.0 <= u, 1, "interval is empty"); - lua_pushnumber(L, l_mathop(floor)(r*u) + (lua_Number)(1.0)); /* [1, u] */ + low = 1; + up = luaL_checkinteger(L, 1); break; } case 2: { /* lower and upper limits */ - lua_Number l = luaL_checknumber(L, 1); - lua_Number u = luaL_checknumber(L, 2); - luaL_argcheck(L, l <= u, 2, "interval is empty"); - lua_pushnumber(L, l_mathop(floor)(r*(u-l+1)) + l); /* [l, u] */ + low = luaL_checkinteger(L, 1); + up = luaL_checkinteger(L, 2); break; } default: return luaL_error(L, "wrong number of arguments"); } + /* random integer in the interval [low, up] */ + luaL_argcheck(L, low <= up, 1, "interval is empty"); + luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1, + "interval too large"); + r *= (double)(up - low) + 1.0; + lua_pushinteger(L, (lua_Integer)r + low); return 1; } static int math_randomseed (lua_State *L) { - srand(luaL_checkunsigned(L, 1)); - (void)rand(); /* discard first value to avoid undesirable correlations */ + l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1)); + (void)l_rand(); /* discard first value to avoid undesirable correlations */ return 0; } +static int math_type (lua_State *L) { + if (lua_type(L, 1) == LUA_TNUMBER) { + if (lua_isinteger(L, 1)) + lua_pushliteral(L, "integer"); + else + lua_pushliteral(L, "float"); + } + else { + luaL_checkany(L, 1); + lua_pushnil(L); + } + return 1; +} + + +/* +** {================================================================== +** Deprecated functions (for compatibility only) +** =================================================================== +*/ +#if defined(LUA_COMPAT_MATHLIB) + +static int math_cosh (lua_State *L) { + lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_sinh (lua_State *L) { + lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_tanh (lua_State *L) { + lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_pow (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + lua_Number y = luaL_checknumber(L, 2); + lua_pushnumber(L, l_mathop(pow)(x, y)); + return 1; +} + +static int math_frexp (lua_State *L) { + int e; + lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e)); + lua_pushinteger(L, e); + return 2; +} + +static int math_ldexp (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + int ep = (int)luaL_checkinteger(L, 2); + lua_pushnumber(L, l_mathop(ldexp)(x, ep)); + return 1; +} + +static int math_log10 (lua_State *L) { + lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1))); + return 1; +} + +#endif +/* }================================================================== */ + + + static const luaL_Reg mathlib[] = { {"abs", math_abs}, {"acos", math_acos}, {"asin", math_asin}, - {"atan2", math_atan2}, {"atan", math_atan}, {"ceil", math_ceil}, - {"cosh", math_cosh}, {"cos", math_cos}, {"deg", math_deg}, {"exp", math_exp}, + {"tointeger", math_toint}, {"floor", math_floor}, {"fmod", math_fmod}, - {"frexp", math_frexp}, - {"ldexp", math_ldexp}, -#if defined(LUA_COMPAT_LOG10) - {"log10", math_log10}, -#endif + {"ult", math_ult}, {"log", math_log}, {"max", math_max}, {"min", math_min}, {"modf", math_modf}, - {"pow", math_pow}, {"rad", math_rad}, {"random", math_random}, {"randomseed", math_randomseed}, - {"sinh", math_sinh}, {"sin", math_sin}, {"sqrt", math_sqrt}, - {"tanh", math_tanh}, {"tan", math_tan}, + {"type", math_type}, +#if defined(LUA_COMPAT_MATHLIB) + {"atan2", math_atan}, + {"cosh", math_cosh}, + {"sinh", math_sinh}, + {"tanh", math_tanh}, + {"pow", math_pow}, + {"frexp", math_frexp}, + {"ldexp", math_ldexp}, + {"log10", math_log10}, +#endif + /* placeholders */ + {"pi", NULL}, + {"huge", NULL}, + {"maxinteger", NULL}, + {"mininteger", NULL}, {NULL, NULL} }; @@ -272,8 +399,12 @@ LUAMOD_API int luaopen_math (lua_State *L) { luaL_newlib(L, mathlib); lua_pushnumber(L, PI); lua_setfield(L, -2, "pi"); - lua_pushnumber(L, HUGE_VAL); + lua_pushnumber(L, (lua_Number)HUGE_VAL); lua_setfield(L, -2, "huge"); + lua_pushinteger(L, LUA_MAXINTEGER); + lua_setfield(L, -2, "maxinteger"); + lua_pushinteger(L, LUA_MININTEGER); + lua_setfield(L, -2, "mininteger"); return 1; } diff --git a/depends/lua/src/lmem.c b/depends/lua/src/lmem.c index ee343e3e03..0241cc3bac 100644 --- a/depends/lua/src/lmem.c +++ b/depends/lua/src/lmem.c @@ -1,15 +1,17 @@ /* -** $Id: lmem.c,v 1.84.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lmem.c,v 1.91.1.1 2017/04/19 17:20:42 roberto Exp $ ** Interface to Memory Manager ** See Copyright Notice in lua.h */ - -#include - #define lmem_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" #include "ldebug.h" @@ -24,15 +26,15 @@ /* ** About the realloc function: ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize); -** (`osize' is the old size, `nsize' is the new size) +** ('osize' is the old size, 'nsize' is the new size) ** -** * frealloc(ud, NULL, x, s) creates a new block of size `s' (no +** * frealloc(ud, NULL, x, s) creates a new block of size 's' (no ** matter 'x'). ** -** * frealloc(ud, p, x, 0) frees the block `p' +** * frealloc(ud, p, x, 0) frees the block 'p' ** (in this specific case, frealloc must return NULL); ** particularly, frealloc(ud, NULL, 0, 0) does nothing -** (which is equivalent to free(NULL) in ANSI C) +** (which is equivalent to free(NULL) in ISO C) ** ** frealloc returns NULL if it cannot create or reallocate the area ** (any reallocation to an equal or smaller size cannot fail!) @@ -83,9 +85,8 @@ void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { #endif newblock = (*g->frealloc)(g->ud, block, osize, nsize); if (newblock == NULL && nsize > 0) { - api_check(L, nsize > realosize, - "realloc cannot fail when shrinking a block"); - if (g->gcrunning) { + lua_assert(nsize > realosize); /* cannot fail when shrinking a block */ + if (g->version) { /* is state fully built? */ luaC_fullgc(L, 1); /* try to free some memory... */ newblock = (*g->frealloc)(g->ud, block, osize, nsize); /* try again */ } diff --git a/depends/lua/src/loadlib.c b/depends/lua/src/loadlib.c index bedbea3e9a..45f44d3225 100644 --- a/depends/lua/src/loadlib.c +++ b/depends/lua/src/loadlib.c @@ -1,5 +1,5 @@ /* -** $Id: loadlib.c,v 1.111.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: loadlib.c,v 1.130.1.1 2017/04/19 17:20:42 roberto Exp $ ** Dynamic library loader for Lua ** See Copyright Notice in lua.h ** @@ -8,22 +8,16 @@ ** systems. */ +#define loadlib_c +#define LUA_LIB -/* -** if needed, includes windows header before everything else -*/ -#if defined(_WIN32) -#include -#endif +#include "lprefix.h" +#include #include #include - -#define loadlib_c -#define LUA_LIB - #include "lua.h" #include "lauxlib.h" @@ -31,40 +25,9 @@ /* -** LUA_PATH and LUA_CPATH are the names of the environment -** variables that Lua check to set its paths. -*/ -#if !defined(LUA_PATH) -#define LUA_PATH "LUA_PATH" -#endif - -#if !defined(LUA_CPATH) -#define LUA_CPATH "LUA_CPATH" -#endif - -#define LUA_PATHSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR - -#define LUA_PATHVERSION LUA_PATH LUA_PATHSUFFIX -#define LUA_CPATHVERSION LUA_CPATH LUA_PATHSUFFIX - -/* -** LUA_PATH_SEP is the character that separates templates in a path. -** LUA_PATH_MARK is the string that marks the substitution points in a -** template. -** LUA_EXEC_DIR in a Windows path is replaced by the executable's -** directory. ** LUA_IGMARK is a mark to ignore all before it when building the ** luaopen_ function name. */ -#if !defined (LUA_PATH_SEP) -#define LUA_PATH_SEP ";" -#endif -#if !defined (LUA_PATH_MARK) -#define LUA_PATH_MARK "?" -#endif -#if !defined (LUA_EXEC_DIR) -#define LUA_EXEC_DIR "!" -#endif #if !defined (LUA_IGMARK) #define LUA_IGMARK "-" #endif @@ -92,29 +55,46 @@ #define LUA_OFSEP "_" -/* table (in the registry) that keeps handles for all loaded C libraries */ -#define CLIBS "_CLIBS" +/* +** unique key for table in the registry that keeps handles +** for all loaded C libraries +*/ +static const int CLIBS = 0; #define LIB_FAIL "open" -/* error codes for ll_loadfunc */ -#define ERRLIB 1 -#define ERRFUNC 2 - -#define setprogdir(L) ((void)0) +#define setprogdir(L) ((void)0) /* ** system-dependent functions */ -static void ll_unloadlib (void *lib); -static void *ll_load (lua_State *L, const char *path, int seeglb); -static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym); + +/* +** unload library 'lib' +*/ +static void lsys_unloadlib (void *lib); + +/* +** load C library in file 'path'. If 'seeglb', load with all names in +** the library global. +** Returns the library; in case of error, returns NULL plus an +** error string in the stack. +*/ +static void *lsys_load (lua_State *L, const char *path, int seeglb); + +/* +** Try to find a function named 'sym' in library 'lib'. +** Returns the function; in case of error, returns NULL plus an +** error string in the stack. +*/ +static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym); + -#if defined(LUA_USE_DLOPEN) +#if defined(LUA_USE_DLOPEN) /* { */ /* ** {======================================================================== ** This is an implementation of loadlib based on the dlfcn interface. @@ -126,20 +106,32 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym); #include -static void ll_unloadlib (void *lib) { +/* +** Macro to convert pointer-to-void* to pointer-to-function. This cast +** is undefined according to ISO C, but POSIX assumes that it works. +** (The '__extension__' in gnu compilers is only to avoid warnings.) +*/ +#if defined(__GNUC__) +#define cast_func(p) (__extension__ (lua_CFunction)(p)) +#else +#define cast_func(p) ((lua_CFunction)(p)) +#endif + + +static void lsys_unloadlib (void *lib) { dlclose(lib); } -static void *ll_load (lua_State *L, const char *path, int seeglb) { +static void *lsys_load (lua_State *L, const char *path, int seeglb) { void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL)); if (lib == NULL) lua_pushstring(L, dlerror()); return lib; } -static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { - lua_CFunction f = (lua_CFunction)dlsym(lib, sym); +static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) { + lua_CFunction f = cast_func(dlsym(lib, sym)); if (f == NULL) lua_pushstring(L, dlerror()); return f; } @@ -148,14 +140,15 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { -#elif defined(LUA_DL_DLL) +#elif defined(LUA_DL_DLL) /* }{ */ /* ** {====================================================================== ** This is an implementation of loadlib for Windows using native functions. ** ======================================================================= */ -#undef setprogdir +#include + /* ** optional flags for LoadLibraryEx @@ -165,21 +158,30 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { #endif +#undef setprogdir + + +/* +** Replace in the path (on the top of the stack) any occurrence +** of LUA_EXEC_DIR with the executable's path. +*/ static void setprogdir (lua_State *L) { char buff[MAX_PATH + 1]; char *lb; DWORD nsize = sizeof(buff)/sizeof(char); - DWORD n = GetModuleFileNameA(NULL, buff, nsize); + DWORD n = GetModuleFileNameA(NULL, buff, nsize); /* get exec. name */ if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL) luaL_error(L, "unable to get ModuleFileName"); else { - *lb = '\0'; + *lb = '\0'; /* cut name on the last '\\' to get the path */ luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff); lua_remove(L, -2); /* remove original string */ } } + + static void pusherror (lua_State *L) { int error = GetLastError(); char buffer[128]; @@ -190,12 +192,12 @@ static void pusherror (lua_State *L) { lua_pushfstring(L, "system error %d\n", error); } -static void ll_unloadlib (void *lib) { +static void lsys_unloadlib (void *lib) { FreeLibrary((HMODULE)lib); } -static void *ll_load (lua_State *L, const char *path, int seeglb) { +static void *lsys_load (lua_State *L, const char *path, int seeglb) { HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS); (void)(seeglb); /* not used: symbols are 'global' by default */ if (lib == NULL) pusherror(L); @@ -203,7 +205,7 @@ static void *ll_load (lua_State *L, const char *path, int seeglb) { } -static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { +static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) { lua_CFunction f = (lua_CFunction)GetProcAddress((HMODULE)lib, sym); if (f == NULL) pusherror(L); return f; @@ -212,7 +214,7 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { /* }====================================================== */ -#else +#else /* }{ */ /* ** {====================================================== ** Fallback for other systems @@ -226,31 +228,95 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { #define DLMSG "dynamic libraries not enabled; check your Lua installation" -static void ll_unloadlib (void *lib) { +static void lsys_unloadlib (void *lib) { (void)(lib); /* not used */ } -static void *ll_load (lua_State *L, const char *path, int seeglb) { +static void *lsys_load (lua_State *L, const char *path, int seeglb) { (void)(path); (void)(seeglb); /* not used */ lua_pushliteral(L, DLMSG); return NULL; } -static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { +static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) { (void)(lib); (void)(sym); /* not used */ lua_pushliteral(L, DLMSG); return NULL; } /* }====================================================== */ +#endif /* } */ + + +/* +** {================================================================== +** Set Paths +** =================================================================== +*/ + +/* +** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment +** variables that Lua check to set its paths. +*/ +#if !defined(LUA_PATH_VAR) +#define LUA_PATH_VAR "LUA_PATH" +#endif + +#if !defined(LUA_CPATH_VAR) +#define LUA_CPATH_VAR "LUA_CPATH" #endif -static void *ll_checkclib (lua_State *L, const char *path) { +#define AUXMARK "\1" /* auxiliary mark */ + + +/* +** return registry.LUA_NOENV as a boolean +*/ +static int noenv (lua_State *L) { + int b; + lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV"); + b = lua_toboolean(L, -1); + lua_pop(L, 1); /* remove value */ + return b; +} + + +/* +** Set a path +*/ +static void setpath (lua_State *L, const char *fieldname, + const char *envname, + const char *dft) { + const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX); + const char *path = getenv(nver); /* use versioned name */ + if (path == NULL) /* no environment variable? */ + path = getenv(envname); /* try unversioned name */ + if (path == NULL || noenv(L)) /* no environment variable? */ + lua_pushstring(L, dft); /* use default */ + else { + /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */ + path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP, + LUA_PATH_SEP AUXMARK LUA_PATH_SEP); + luaL_gsub(L, path, AUXMARK, dft); + lua_remove(L, -2); /* remove result from 1st 'gsub' */ + } + setprogdir(L); + lua_setfield(L, -3, fieldname); /* package[fieldname] = path value */ + lua_pop(L, 1); /* pop versioned variable name */ +} + +/* }================================================================== */ + + +/* +** return registry.CLIBS[path] +*/ +static void *checkclib (lua_State *L, const char *path) { void *plib; - lua_getfield(L, LUA_REGISTRYINDEX, CLIBS); + lua_rawgetp(L, LUA_REGISTRYINDEX, &CLIBS); lua_getfield(L, -1, path); plib = lua_touserdata(L, -1); /* plib = CLIBS[path] */ lua_pop(L, 2); /* pop CLIBS table and 'plib' */ @@ -258,8 +324,12 @@ static void *ll_checkclib (lua_State *L, const char *path) { } -static void ll_addtoclib (lua_State *L, const char *path, void *plib) { - lua_getfield(L, LUA_REGISTRYINDEX, CLIBS); +/* +** registry.CLIBS[path] = plib -- for queries +** registry.CLIBS[#CLIBS + 1] = plib -- also keep a list of all libraries +*/ +static void addtoclib (lua_State *L, const char *path, void *plib) { + lua_rawgetp(L, LUA_REGISTRYINDEX, &CLIBS); lua_pushlightuserdata(L, plib); lua_pushvalue(L, -1); lua_setfield(L, -3, path); /* CLIBS[path] = plib */ @@ -269,33 +339,49 @@ static void ll_addtoclib (lua_State *L, const char *path, void *plib) { /* -** __gc tag method for CLIBS table: calls 'll_unloadlib' for all lib +** __gc tag method for CLIBS table: calls 'lsys_unloadlib' for all lib ** handles in list CLIBS */ static int gctm (lua_State *L) { - int n = luaL_len(L, 1); + lua_Integer n = luaL_len(L, 1); for (; n >= 1; n--) { /* for each handle, in reverse order */ lua_rawgeti(L, 1, n); /* get handle CLIBS[n] */ - ll_unloadlib(lua_touserdata(L, -1)); + lsys_unloadlib(lua_touserdata(L, -1)); lua_pop(L, 1); /* pop handle */ } return 0; } -static int ll_loadfunc (lua_State *L, const char *path, const char *sym) { - void *reg = ll_checkclib(L, path); /* check loaded C libraries */ + +/* error codes for 'lookforfunc' */ +#define ERRLIB 1 +#define ERRFUNC 2 + +/* +** Look for a C function named 'sym' in a dynamically loaded library +** 'path'. +** First, check whether the library is already loaded; if not, try +** to load it. +** Then, if 'sym' is '*', return true (as library has been loaded). +** Otherwise, look for symbol 'sym' in the library and push a +** C function with that symbol. +** Return 0 and 'true' or a function in the stack; in case of +** errors, return an error code and an error message in the stack. +*/ +static int lookforfunc (lua_State *L, const char *path, const char *sym) { + void *reg = checkclib(L, path); /* check loaded C libraries */ if (reg == NULL) { /* must load library? */ - reg = ll_load(L, path, *sym == '*'); + reg = lsys_load(L, path, *sym == '*'); /* global symbols if 'sym'=='*' */ if (reg == NULL) return ERRLIB; /* unable to load library */ - ll_addtoclib(L, path, reg); + addtoclib(L, path, reg); } if (*sym == '*') { /* loading only library (no function)? */ lua_pushboolean(L, 1); /* return 'true' */ return 0; /* no errors */ } else { - lua_CFunction f = ll_sym(L, reg, sym); + lua_CFunction f = lsys_sym(L, reg, sym); if (f == NULL) return ERRFUNC; /* unable to find function */ lua_pushcfunction(L, f); /* else create new function */ @@ -307,7 +393,7 @@ static int ll_loadfunc (lua_State *L, const char *path, const char *sym) { static int ll_loadlib (lua_State *L) { const char *path = luaL_checkstring(L, 1); const char *init = luaL_checkstring(L, 2); - int stat = ll_loadfunc(L, path, init); + int stat = lookforfunc(L, path, init); if (stat == 0) /* no errors? */ return 1; /* return the loaded function */ else { /* error; error message is on stack top */ @@ -360,7 +446,7 @@ static const char *searchpath (lua_State *L, const char *name, lua_remove(L, -2); /* remove path template */ if (readable(filename)) /* does file exist and is readable? */ return filename; /* return that file name */ - lua_pushfstring(L, "\n\tno file " LUA_QS, filename); + lua_pushfstring(L, "\n\tno file '%s'", filename); lua_remove(L, -2); /* remove file name */ luaL_addvalue(&msg); /* concatenate error msg. entry */ } @@ -390,7 +476,7 @@ static const char *findfile (lua_State *L, const char *name, lua_getfield(L, lua_upvalueindex(1), pname); path = lua_tostring(L, -1); if (path == NULL) - luaL_error(L, LUA_QL("package.%s") " must be a string", pname); + luaL_error(L, "'package.%s' must be a string", pname); return searchpath(L, name, path, ".", dirsep); } @@ -401,8 +487,7 @@ static int checkload (lua_State *L, int stat, const char *filename) { return 2; /* return open function and file name */ } else - return luaL_error(L, "error loading module " LUA_QS - " from file " LUA_QS ":\n\t%s", + return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s", lua_tostring(L, 1), filename, lua_tostring(L, -1)); } @@ -416,21 +501,29 @@ static int searcher_Lua (lua_State *L) { } +/* +** Try to find a load function for module 'modname' at file 'filename'. +** First, change '.' to '_' in 'modname'; then, if 'modname' has +** the form X-Y (that is, it has an "ignore mark"), build a function +** name "luaopen_X" and look for it. (For compatibility, if that +** fails, it also tries "luaopen_Y".) If there is no ignore mark, +** look for a function named "luaopen_modname". +*/ static int loadfunc (lua_State *L, const char *filename, const char *modname) { - const char *funcname; + const char *openfunc; const char *mark; modname = luaL_gsub(L, modname, ".", LUA_OFSEP); mark = strchr(modname, *LUA_IGMARK); if (mark) { int stat; - funcname = lua_pushlstring(L, modname, mark - modname); - funcname = lua_pushfstring(L, LUA_POF"%s", funcname); - stat = ll_loadfunc(L, filename, funcname); + openfunc = lua_pushlstring(L, modname, mark - modname); + openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc); + stat = lookforfunc(L, filename, openfunc); if (stat != ERRFUNC) return stat; modname = mark + 1; /* else go ahead and try old-style name */ } - funcname = lua_pushfstring(L, LUA_POF"%s", modname); - return ll_loadfunc(L, filename, funcname); + openfunc = lua_pushfstring(L, LUA_POF"%s", modname); + return lookforfunc(L, filename, openfunc); } @@ -455,8 +548,7 @@ static int searcher_Croot (lua_State *L) { if (stat != ERRFUNC) return checkload(L, 0, filename); /* real error */ else { /* open function not found */ - lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS, - name, filename); + lua_pushfstring(L, "\n\tno module '%s' in file '%s'", name, filename); return 1; } } @@ -467,9 +559,8 @@ static int searcher_Croot (lua_State *L) { static int searcher_preload (lua_State *L) { const char *name = luaL_checkstring(L, 1); - lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD"); - lua_getfield(L, -1, name); - if (lua_isnil(L, -1)) /* not found? */ + lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE); + if (lua_getfield(L, -1, name) == LUA_TNIL) /* not found? */ lua_pushfstring(L, "\n\tno field package.preload['%s']", name); return 1; } @@ -479,17 +570,15 @@ static void findloader (lua_State *L, const char *name) { int i; luaL_Buffer msg; /* to build error message */ luaL_buffinit(L, &msg); - lua_getfield(L, lua_upvalueindex(1), "searchers"); /* will be at index 3 */ - if (!lua_istable(L, 3)) - luaL_error(L, LUA_QL("package.searchers") " must be a table"); + /* push 'package.searchers' to index 3 in the stack */ + if (lua_getfield(L, lua_upvalueindex(1), "searchers") != LUA_TTABLE) + luaL_error(L, "'package.searchers' must be a table"); /* iterate over available searchers to find a loader */ for (i = 1; ; i++) { - lua_rawgeti(L, 3, i); /* get a searcher */ - if (lua_isnil(L, -1)) { /* no more searchers? */ + if (lua_rawgeti(L, 3, i) == LUA_TNIL) { /* no more searchers? */ lua_pop(L, 1); /* remove nil */ luaL_pushresult(&msg); /* create error message */ - luaL_error(L, "module " LUA_QS " not found:%s", - name, lua_tostring(L, -1)); + luaL_error(L, "module '%s' not found:%s", name, lua_tostring(L, -1)); } lua_pushstring(L, name); lua_call(L, 1, 2); /* call it */ @@ -507,9 +596,9 @@ static void findloader (lua_State *L, const char *name) { static int ll_require (lua_State *L) { const char *name = luaL_checkstring(L, 1); - lua_settop(L, 1); /* _LOADED table will be at index 2 */ - lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED"); - lua_getfield(L, 2, name); /* _LOADED[name] */ + lua_settop(L, 1); /* LOADED table will be at index 2 */ + lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); + lua_getfield(L, 2, name); /* LOADED[name] */ if (lua_toboolean(L, -1)) /* is it there? */ return 1; /* package is already loaded */ /* else must load package */ @@ -519,12 +608,11 @@ static int ll_require (lua_State *L) { lua_insert(L, -2); /* name is 1st argument (before search data) */ lua_call(L, 2, 1); /* run loader to load module */ if (!lua_isnil(L, -1)) /* non-nil return? */ - lua_setfield(L, 2, name); /* _LOADED[name] = returned value */ - lua_getfield(L, 2, name); - if (lua_isnil(L, -1)) { /* module did not set a value? */ + lua_setfield(L, 2, name); /* LOADED[name] = returned value */ + if (lua_getfield(L, 2, name) == LUA_TNIL) { /* module set no value? */ lua_pushboolean(L, 1); /* use true as result */ lua_pushvalue(L, -1); /* extra copy to be returned */ - lua_setfield(L, 2, name); /* _LOADED[name] = true */ + lua_setfield(L, 2, name); /* LOADED[name] = true */ } return 1; } @@ -548,7 +636,7 @@ static void set_env (lua_State *L) { if (lua_getstack(L, 1, &ar) == 0 || lua_getinfo(L, "f", &ar) == 0 || /* get calling function */ lua_iscfunction(L, -1)) - luaL_error(L, LUA_QL("module") " not called from a Lua function"); + luaL_error(L, "'module' not called from a Lua function"); lua_pushvalue(L, -2); /* copy new environment table to top */ lua_setupvalue(L, -2, 1); lua_pop(L, 1); /* remove function */ @@ -587,9 +675,8 @@ static int ll_module (lua_State *L) { int lastarg = lua_gettop(L); /* last parameter */ luaL_pushmodule(L, modname, 1); /* get/create module table */ /* check whether table already has a _NAME field */ - lua_getfield(L, -1, "_NAME"); - if (!lua_isnil(L, -1)) /* is table an initialized module? */ - lua_pop(L, 1); + if (lua_getfield(L, -1, "_NAME") != LUA_TNIL) + lua_pop(L, 1); /* table is an initialized module */ else { /* no; initialize it */ lua_pop(L, 1); modinit(L, modname); @@ -618,47 +705,18 @@ static int ll_seeall (lua_State *L) { -/* auxiliary mark (for internal use) */ -#define AUXMARK "\1" - - -/* -** return registry.LUA_NOENV as a boolean -*/ -static int noenv (lua_State *L) { - int b; - lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV"); - b = lua_toboolean(L, -1); - lua_pop(L, 1); /* remove value */ - return b; -} - - -static void setpath (lua_State *L, const char *fieldname, const char *envname1, - const char *envname2, const char *def) { - const char *path = getenv(envname1); - if (path == NULL) /* no environment variable? */ - path = getenv(envname2); /* try alternative name */ - if (path == NULL || noenv(L)) /* no environment variable? */ - lua_pushstring(L, def); /* use default */ - else { - /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */ - path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP, - LUA_PATH_SEP AUXMARK LUA_PATH_SEP); - luaL_gsub(L, path, AUXMARK, def); - lua_remove(L, -2); - } - setprogdir(L); - lua_setfield(L, -2, fieldname); -} - - static const luaL_Reg pk_funcs[] = { {"loadlib", ll_loadlib}, {"searchpath", ll_searchpath}, #if defined(LUA_COMPAT_MODULE) {"seeall", ll_seeall}, #endif + /* placeholders */ + {"preload", NULL}, + {"cpath", NULL}, + {"path", NULL}, + {"searchers", NULL}, + {"loaded", NULL}, {NULL, NULL} }; @@ -678,43 +736,50 @@ static void createsearcherstable (lua_State *L) { int i; /* create 'searchers' table */ lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0); - /* fill it with pre-defined searchers */ + /* fill it with predefined searchers */ for (i=0; searchers[i] != NULL; i++) { lua_pushvalue(L, -2); /* set 'package' as upvalue for all searchers */ lua_pushcclosure(L, searchers[i], 1); lua_rawseti(L, -2, i+1); } +#if defined(LUA_COMPAT_LOADERS) + lua_pushvalue(L, -1); /* make a copy of 'searchers' table */ + lua_setfield(L, -3, "loaders"); /* put it in field 'loaders' */ +#endif + lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */ } -LUAMOD_API int luaopen_package (lua_State *L) { - /* create table CLIBS to keep track of loaded C libraries */ - luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS); - lua_createtable(L, 0, 1); /* metatable for CLIBS */ +/* +** create table CLIBS to keep track of loaded C libraries, +** setting a finalizer to close all libraries when closing state. +*/ +static void createclibstable (lua_State *L) { + lua_newtable(L); /* create CLIBS table */ + lua_createtable(L, 0, 1); /* create metatable for CLIBS */ lua_pushcfunction(L, gctm); lua_setfield(L, -2, "__gc"); /* set finalizer for CLIBS table */ lua_setmetatable(L, -2); - /* create `package' table */ - luaL_newlib(L, pk_funcs); + lua_rawsetp(L, LUA_REGISTRYINDEX, &CLIBS); /* set CLIBS table in registry */ +} + + +LUAMOD_API int luaopen_package (lua_State *L) { + createclibstable(L); + luaL_newlib(L, pk_funcs); /* create 'package' table */ createsearcherstable(L); -#if defined(LUA_COMPAT_LOADERS) - lua_pushvalue(L, -1); /* make a copy of 'searchers' table */ - lua_setfield(L, -3, "loaders"); /* put it in field `loaders' */ -#endif - lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */ - /* set field 'path' */ - setpath(L, "path", LUA_PATHVERSION, LUA_PATH, LUA_PATH_DEFAULT); - /* set field 'cpath' */ - setpath(L, "cpath", LUA_CPATHVERSION, LUA_CPATH, LUA_CPATH_DEFAULT); + /* set paths */ + setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT); + setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT); /* store config information */ lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n" LUA_EXEC_DIR "\n" LUA_IGMARK "\n"); lua_setfield(L, -2, "config"); - /* set field `loaded' */ - luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED"); + /* set field 'loaded' */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); lua_setfield(L, -2, "loaded"); - /* set field `preload' */ - luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD"); + /* set field 'preload' */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE); lua_setfield(L, -2, "preload"); lua_pushglobaltable(L); lua_pushvalue(L, -2); /* set 'package' as upvalue for next lib */ diff --git a/depends/lua/src/lobject.c b/depends/lua/src/lobject.c index 882d994d41..355bf58d63 100644 --- a/depends/lua/src/lobject.c +++ b/depends/lua/src/lobject.c @@ -1,17 +1,22 @@ /* -** $Id: lobject.c,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lobject.c,v 2.113.1.1 2017/04/19 17:29:57 roberto Exp $ ** Some generic functions over Lua objects ** See Copyright Notice in lua.h */ +#define lobject_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include #include #include #include #include -#define lobject_c -#define LUA_CORE - #include "lua.h" #include "lctype.h" @@ -36,8 +41,12 @@ LUAI_DDEF const TValue luaO_nilobject_ = {NILCONSTANT}; int luaO_int2fb (unsigned int x) { int e = 0; /* exponent */ if (x < 8) return x; - while (x >= 0x10) { - x = (x+1) >> 1; + while (x >= (8 << 4)) { /* coarse steps */ + x = (x + 0xf) >> 4; /* x = ceil(x / 16) */ + e += 4; + } + while (x >= (8 << 1)) { /* fine steps */ + x = (x + 1) >> 1; /* x = ceil(x / 2) */ e++; } return ((e+1) << 3) | (cast_int(x) - 8); @@ -46,14 +55,15 @@ int luaO_int2fb (unsigned int x) { /* converts back */ int luaO_fb2int (int x) { - int e = (x >> 3) & 0x1f; - if (e == 0) return x; - else return ((x & 7) + 8) << (e - 1); + return (x < 8) ? x : ((x & 7) + 8) << ((x >> 3) - 1); } +/* +** Computes ceil(log2(x)) +*/ int luaO_ceillog2 (unsigned int x) { - static const lu_byte log_2[256] = { + static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */ 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, @@ -70,29 +80,90 @@ int luaO_ceillog2 (unsigned int x) { } -lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2) { +static lua_Integer intarith (lua_State *L, int op, lua_Integer v1, + lua_Integer v2) { switch (op) { - case LUA_OPADD: return luai_numadd(NULL, v1, v2); - case LUA_OPSUB: return luai_numsub(NULL, v1, v2); - case LUA_OPMUL: return luai_nummul(NULL, v1, v2); - case LUA_OPDIV: return luai_numdiv(NULL, v1, v2); - case LUA_OPMOD: return luai_nummod(NULL, v1, v2); - case LUA_OPPOW: return luai_numpow(NULL, v1, v2); - case LUA_OPUNM: return luai_numunm(NULL, v1); + case LUA_OPADD: return intop(+, v1, v2); + case LUA_OPSUB:return intop(-, v1, v2); + case LUA_OPMUL:return intop(*, v1, v2); + case LUA_OPMOD: return luaV_mod(L, v1, v2); + case LUA_OPIDIV: return luaV_div(L, v1, v2); + case LUA_OPBAND: return intop(&, v1, v2); + case LUA_OPBOR: return intop(|, v1, v2); + case LUA_OPBXOR: return intop(^, v1, v2); + case LUA_OPSHL: return luaV_shiftl(v1, v2); + case LUA_OPSHR: return luaV_shiftl(v1, -v2); + case LUA_OPUNM: return intop(-, 0, v1); + case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); default: lua_assert(0); return 0; } } -int luaO_hexavalue (int c) { - if (lisdigit(c)) return c - '0'; - else return ltolower(c) - 'a' + 10; +static lua_Number numarith (lua_State *L, int op, lua_Number v1, + lua_Number v2) { + switch (op) { + case LUA_OPADD: return luai_numadd(L, v1, v2); + case LUA_OPSUB: return luai_numsub(L, v1, v2); + case LUA_OPMUL: return luai_nummul(L, v1, v2); + case LUA_OPDIV: return luai_numdiv(L, v1, v2); + case LUA_OPPOW: return luai_numpow(L, v1, v2); + case LUA_OPIDIV: return luai_numidiv(L, v1, v2); + case LUA_OPUNM: return luai_numunm(L, v1); + case LUA_OPMOD: { + lua_Number m; + luai_nummod(L, v1, v2, m); + return m; + } + default: lua_assert(0); return 0; + } } -#if !defined(lua_strx2number) +void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2, + TValue *res) { + switch (op) { + case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: + case LUA_OPSHL: case LUA_OPSHR: + case LUA_OPBNOT: { /* operate only on integers */ + lua_Integer i1; lua_Integer i2; + if (tointeger(p1, &i1) && tointeger(p2, &i2)) { + setivalue(res, intarith(L, op, i1, i2)); + return; + } + else break; /* go to the end */ + } + case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ + lua_Number n1; lua_Number n2; + if (tonumber(p1, &n1) && tonumber(p2, &n2)) { + setfltvalue(res, numarith(L, op, n1, n2)); + return; + } + else break; /* go to the end */ + } + default: { /* other operations */ + lua_Number n1; lua_Number n2; + if (ttisinteger(p1) && ttisinteger(p2)) { + setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2))); + return; + } + else if (tonumber(p1, &n1) && tonumber(p2, &n2)) { + setfltvalue(res, numarith(L, op, n1, n2)); + return; + } + else break; /* go to the end */ + } + } + /* could not perform raw operation; try metamethod */ + lua_assert(L != NULL); /* should not fail when folding (compile time) */ + luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD)); +} -#include + +int luaO_hexavalue (int c) { + if (lisdigit(c)) return c - '0'; + else return (ltolower(c) - 'a') + 10; +} static int isneg (const char **s) { @@ -102,122 +173,286 @@ static int isneg (const char **s) { } -static lua_Number readhexa (const char **s, lua_Number r, int *count) { - for (; lisxdigit(cast_uchar(**s)); (*s)++) { /* read integer part */ - r = (r * cast_num(16.0)) + cast_num(luaO_hexavalue(cast_uchar(**s))); - (*count)++; - } - return r; -} +/* +** {================================================================== +** Lua's implementation for 'lua_strx2number' +** =================================================================== +*/ + +#if !defined(lua_strx2number) + +/* maximum number of significant digits to read (to avoid overflows + even with single floats) */ +#define MAXSIGDIG 30 /* ** convert an hexadecimal numeric string to a number, following ** C99 specification for 'strtod' */ static lua_Number lua_strx2number (const char *s, char **endptr) { - lua_Number r = 0.0; - int e = 0, i = 0; - int neg = 0; /* 1 if number is negative */ + int dot = lua_getlocaledecpoint(); + lua_Number r = 0.0; /* result (accumulator) */ + int sigdig = 0; /* number of significant digits */ + int nosigdig = 0; /* number of non-significant digits */ + int e = 0; /* exponent correction */ + int neg; /* 1 if number is negative */ + int hasdot = 0; /* true after seen a dot */ *endptr = cast(char *, s); /* nothing is valid yet */ while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ neg = isneg(&s); /* check signal */ if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))) /* check '0x' */ return 0.0; /* invalid format (no '0x') */ - s += 2; /* skip '0x' */ - r = readhexa(&s, r, &i); /* read integer part */ - if (*s == '.') { - s++; /* skip dot */ - r = readhexa(&s, r, &e); /* read fractional part */ + for (s += 2; ; s++) { /* skip '0x' and read numeral */ + if (*s == dot) { + if (hasdot) break; /* second dot? stop loop */ + else hasdot = 1; + } + else if (lisxdigit(cast_uchar(*s))) { + if (sigdig == 0 && *s == '0') /* non-significant digit (zero)? */ + nosigdig++; + else if (++sigdig <= MAXSIGDIG) /* can read it without overflow? */ + r = (r * cast_num(16.0)) + luaO_hexavalue(*s); + else e++; /* too many digits; ignore, but still count for exponent */ + if (hasdot) e--; /* decimal digit? correct exponent */ + } + else break; /* neither a dot nor a digit */ } - if (i == 0 && e == 0) - return 0.0; /* invalid format (no digit) */ - e *= -4; /* each fractional digit divides value by 2^-4 */ + if (nosigdig + sigdig == 0) /* no digits? */ + return 0.0; /* invalid format */ *endptr = cast(char *, s); /* valid up to here */ + e *= 4; /* each digit multiplies/divides value by 2^4 */ if (*s == 'p' || *s == 'P') { /* exponent part? */ - int exp1 = 0; - int neg1; + int exp1 = 0; /* exponent value */ + int neg1; /* exponent signal */ s++; /* skip 'p' */ neg1 = isneg(&s); /* signal */ if (!lisdigit(cast_uchar(*s))) - goto ret; /* must have at least one digit */ + return 0.0; /* invalid; must have at least one digit */ while (lisdigit(cast_uchar(*s))) /* read exponent */ exp1 = exp1 * 10 + *(s++) - '0'; if (neg1) exp1 = -exp1; e += exp1; + *endptr = cast(char *, s); /* valid up to here */ } - *endptr = cast(char *, s); /* valid up to here */ - ret: if (neg) r = -r; return l_mathop(ldexp)(r, e); } #endif +/* }====================================================== */ + +/* maximum length of a numeral */ +#if !defined (L_MAXLENNUM) +#define L_MAXLENNUM 200 +#endif -int luaO_str2d (const char *s, size_t len, lua_Number *result) { +static const char *l_str2dloc (const char *s, lua_Number *result, int mode) { char *endptr; - if (strpbrk(s, "nN")) /* reject 'inf' and 'nan' */ - return 0; - else if (strpbrk(s, "xX")) /* hexa? */ - *result = lua_strx2number(s, &endptr); + *result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */ + : lua_str2number(s, &endptr); + if (endptr == s) return NULL; /* nothing recognized? */ + while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */ + return (*endptr == '\0') ? endptr : NULL; /* OK if no trailing characters */ +} + + +/* +** Convert string 's' to a Lua number (put in 'result'). Return NULL +** on fail or the address of the ending '\0' on success. +** 'pmode' points to (and 'mode' contains) special things in the string: +** - 'x'/'X' means an hexadecimal numeral +** - 'n'/'N' means 'inf' or 'nan' (which should be rejected) +** - '.' just optimizes the search for the common case (nothing special) +** This function accepts both the current locale or a dot as the radix +** mark. If the conversion fails, it may mean number has a dot but +** locale accepts something else. In that case, the code copies 's' +** to a buffer (because 's' is read-only), changes the dot to the +** current locale radix mark, and tries to convert again. +*/ +static const char *l_str2d (const char *s, lua_Number *result) { + const char *endptr; + const char *pmode = strpbrk(s, ".xXnN"); + int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0; + if (mode == 'n') /* reject 'inf' and 'nan' */ + return NULL; + endptr = l_str2dloc(s, result, mode); /* try to convert */ + if (endptr == NULL) { /* failed? may be a different locale */ + char buff[L_MAXLENNUM + 1]; + const char *pdot = strchr(s, '.'); + if (strlen(s) > L_MAXLENNUM || pdot == NULL) + return NULL; /* string too long or no dot; fail */ + strcpy(buff, s); /* copy string to buffer */ + buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */ + endptr = l_str2dloc(buff, result, mode); /* try again */ + if (endptr != NULL) + endptr = s + (endptr - buff); /* make relative to 's' */ + } + return endptr; +} + + +#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) +#define MAXLASTD cast_int(LUA_MAXINTEGER % 10) + +static const char *l_str2int (const char *s, lua_Integer *result) { + lua_Unsigned a = 0; + int empty = 1; + int neg; + while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ + neg = isneg(&s); + if (s[0] == '0' && + (s[1] == 'x' || s[1] == 'X')) { /* hex? */ + s += 2; /* skip '0x' */ + for (; lisxdigit(cast_uchar(*s)); s++) { + a = a * 16 + luaO_hexavalue(*s); + empty = 0; + } + } + else { /* decimal */ + for (; lisdigit(cast_uchar(*s)); s++) { + int d = *s - '0'; + if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ + return NULL; /* do not accept it (as integer) */ + a = a * 10 + d; + empty = 0; + } + } + while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */ + if (empty || *s != '\0') return NULL; /* something wrong in the numeral */ + else { + *result = l_castU2S((neg) ? 0u - a : a); + return s; + } +} + + +size_t luaO_str2num (const char *s, TValue *o) { + lua_Integer i; lua_Number n; + const char *e; + if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ + setivalue(o, i); + } + else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ + setfltvalue(o, n); + } else - *result = lua_str2number(s, &endptr); - if (endptr == s) return 0; /* nothing recognized */ - while (lisspace(cast_uchar(*endptr))) endptr++; - return (endptr == s + len); /* OK if no trailing characters */ + return 0; /* conversion failed */ + return (e - s) + 1; /* success; return string size */ +} + + +int luaO_utf8esc (char *buff, unsigned long x) { + int n = 1; /* number of bytes put in buffer (backwards) */ + lua_assert(x <= 0x10FFFF); + if (x < 0x80) /* ascii? */ + buff[UTF8BUFFSZ - 1] = cast(char, x); + else { /* need continuation bytes */ + unsigned int mfb = 0x3f; /* maximum that fits in first byte */ + do { /* add continuation bytes */ + buff[UTF8BUFFSZ - (n++)] = cast(char, 0x80 | (x & 0x3f)); + x >>= 6; /* remove added bits */ + mfb >>= 1; /* now there is one less bit available in first byte */ + } while (x > mfb); /* still needs continuation byte? */ + buff[UTF8BUFFSZ - n] = cast(char, (~mfb << 1) | x); /* add first byte */ + } + return n; } +/* maximum length of the conversion of a number to a string */ +#define MAXNUMBER2STR 50 + + +/* +** Convert a number object to a string +*/ +void luaO_tostring (lua_State *L, StkId obj) { + char buff[MAXNUMBER2STR]; + size_t len; + lua_assert(ttisnumber(obj)); + if (ttisinteger(obj)) + len = lua_integer2str(buff, sizeof(buff), ivalue(obj)); + else { + len = lua_number2str(buff, sizeof(buff), fltvalue(obj)); +#if !defined(LUA_COMPAT_FLOATSTRING) + if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */ + buff[len++] = lua_getlocaledecpoint(); + buff[len++] = '0'; /* adds '.0' to result */ + } +#endif + } + setsvalue2s(L, obj, luaS_newlstr(L, buff, len)); +} + static void pushstr (lua_State *L, const char *str, size_t l) { - setsvalue2s(L, L->top++, luaS_newlstr(L, str, l)); + setsvalue2s(L, L->top, luaS_newlstr(L, str, l)); + luaD_inctop(L); } -/* this function handles only `%d', `%c', %f, %p, and `%s' formats */ +/* +** this function handles only '%d', '%c', '%f', '%p', and '%s' + conventional formats, plus Lua-specific '%I' and '%U' +*/ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { int n = 0; for (;;) { const char *e = strchr(fmt, '%'); if (e == NULL) break; - luaD_checkstack(L, 2); /* fmt + item */ pushstr(L, fmt, e - fmt); switch (*(e+1)) { - case 's': { + case 's': { /* zero-terminated string */ const char *s = va_arg(argp, char *); if (s == NULL) s = "(null)"; pushstr(L, s, strlen(s)); break; } - case 'c': { - char buff; - buff = cast(char, va_arg(argp, int)); - pushstr(L, &buff, 1); + case 'c': { /* an 'int' as a character */ + char buff = cast(char, va_arg(argp, int)); + if (lisprint(cast_uchar(buff))) + pushstr(L, &buff, 1); + else /* non-printable character; print its code */ + luaO_pushfstring(L, "<\\%d>", cast_uchar(buff)); break; } - case 'd': { - setnvalue(L->top++, cast_num(va_arg(argp, int))); - break; + case 'd': { /* an 'int' */ + setivalue(L->top, va_arg(argp, int)); + goto top2str; + } + case 'I': { /* a 'lua_Integer' */ + setivalue(L->top, cast(lua_Integer, va_arg(argp, l_uacInt))); + goto top2str; } - case 'f': { - setnvalue(L->top++, cast_num(va_arg(argp, l_uacNumber))); + case 'f': { /* a 'lua_Number' */ + setfltvalue(L->top, cast_num(va_arg(argp, l_uacNumber))); + top2str: /* convert the top element to a string */ + luaD_inctop(L); + luaO_tostring(L, L->top - 1); break; } - case 'p': { - char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */ - int l = sprintf(buff, "%p", va_arg(argp, void *)); + case 'p': { /* a pointer */ + char buff[4*sizeof(void *) + 8]; /* should be enough space for a '%p' */ + void *p = va_arg(argp, void *); + int l = lua_pointer2str(buff, sizeof(buff), p); pushstr(L, buff, l); break; } + case 'U': { /* an 'int' as a UTF-8 sequence */ + char buff[UTF8BUFFSZ]; + int l = luaO_utf8esc(buff, cast(long, va_arg(argp, long))); + pushstr(L, buff + UTF8BUFFSZ - l, l); + break; + } case '%': { pushstr(L, "%", 1); break; } default: { - luaG_runerror(L, - "invalid option " LUA_QL("%%%c") " to " LUA_QL("lua_pushfstring"), - *(e + 1)); + luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'", + *(e + 1)); } } n += 2; diff --git a/depends/lua/src/lopcodes.c b/depends/lua/src/lopcodes.c index 4190dc7624..5ca3eb261a 100644 --- a/depends/lua/src/lopcodes.c +++ b/depends/lua/src/lopcodes.c @@ -1,13 +1,16 @@ /* -** $Id: lopcodes.c,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lopcodes.c,v 1.55.1.1 2017/04/19 17:20:42 roberto Exp $ ** Opcodes for Lua virtual machine ** See Copyright Notice in lua.h */ - #define lopcodes_c #define LUA_CORE +#include "lprefix.h" + + +#include #include "lopcodes.h" @@ -31,10 +34,17 @@ LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = { "ADD", "SUB", "MUL", - "DIV", "MOD", "POW", + "DIV", + "IDIV", + "BAND", + "BOR", + "BXOR", + "SHL", + "SHR", "UNM", + "BNOT", "NOT", "LEN", "CONCAT", @@ -79,10 +89,17 @@ LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = { ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_ADD */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SUB */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MUL */ - ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MOD */ ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_POW */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_IDIV */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_BAND */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_BOR */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_BXOR */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SHL */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SHR */ ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_UNM */ + ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_BNOT */ ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */ ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */ ,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */ diff --git a/depends/lua/src/loslib.c b/depends/lua/src/loslib.c index 052ba17441..de590c6b71 100644 --- a/depends/lua/src/loslib.c +++ b/depends/lua/src/loslib.c @@ -1,9 +1,14 @@ /* -** $Id: loslib.c,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: loslib.c,v 1.65.1.1 2017/04/19 17:29:57 roberto Exp $ ** Standard Operating System library ** See Copyright Notice in lua.h */ +#define loslib_c +#define LUA_LIB + +#include "lprefix.h" + #include #include @@ -11,9 +16,6 @@ #include #include -#define loslib_c -#define LUA_LIB - #include "lua.h" #include "lauxlib.h" @@ -21,60 +23,119 @@ /* -** list of valid conversion specifiers for the 'strftime' function +** {================================================================== +** List of valid conversion specifiers for the 'strftime' function; +** options are grouped by length; group of length 2 start with '||'. +** =================================================================== */ -#if !defined(LUA_STRFTIMEOPTIONS) - -#if !defined(LUA_USE_POSIX) -#define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" } -#else -#define LUA_STRFTIMEOPTIONS \ - { "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "" \ - "", "E", "cCxXyY", \ - "O", "deHImMSuUVwWy" } -#endif +#if !defined(LUA_STRFTIMEOPTIONS) /* { */ +/* options for ANSI C 89 (only 1-char options) */ +#define L_STRFTIMEC89 "aAbBcdHIjmMpSUwWxXyYZ%" + +/* options for ISO C 99 and POSIX */ +#define L_STRFTIMEC99 "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%" \ + "||" "EcECExEXEyEY" "OdOeOHOIOmOMOSOuOUOVOwOWOy" /* two-char options */ + +/* options for Windows */ +#define L_STRFTIMEWIN "aAbBcdHIjmMpSUwWxXyYzZ%" \ + "||" "#c#x#d#H#I#j#m#M#S#U#w#W#y#Y" /* two-char options */ + +#if defined(LUA_USE_WINDOWS) +#define LUA_STRFTIMEOPTIONS L_STRFTIMEWIN +#elif defined(LUA_USE_C89) +#define LUA_STRFTIMEOPTIONS L_STRFTIMEC89 +#else /* C99 specification */ +#define LUA_STRFTIMEOPTIONS L_STRFTIMEC99 #endif +#endif /* } */ +/* }================================================================== */ /* -** By default, Lua uses tmpnam except when POSIX is available, where it -** uses mkstemp. +** {================================================================== +** Configuration for time-related stuff +** =================================================================== */ -#if defined(LUA_USE_MKSTEMP) -#include -#define LUA_TMPNAMBUFSIZE 32 -#define lua_tmpnam(b,e) { \ - strcpy(b, "/tmp/lua_XXXXXX"); \ - e = mkstemp(b); \ - if (e != -1) close(e); \ - e = (e == -1); } -#elif !defined(lua_tmpnam) +#if !defined(l_time_t) /* { */ +/* +** type to represent time_t in Lua +*/ +#define l_timet lua_Integer +#define l_pushtime(L,t) lua_pushinteger(L,(lua_Integer)(t)) -#define LUA_TMPNAMBUFSIZE L_tmpnam -#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } +static time_t l_checktime (lua_State *L, int arg) { + lua_Integer t = luaL_checkinteger(L, arg); + luaL_argcheck(L, (time_t)t == t, arg, "time out-of-bounds"); + return (time_t)t; +} -#endif +#endif /* } */ +#if !defined(l_gmtime) /* { */ /* ** By default, Lua uses gmtime/localtime, except when POSIX is available, ** where it uses gmtime_r/localtime_r */ -#if defined(LUA_USE_GMTIME_R) + +#if defined(LUA_USE_POSIX) /* { */ #define l_gmtime(t,r) gmtime_r(t,r) #define l_localtime(t,r) localtime_r(t,r) -#elif !defined(l_gmtime) +#else /* }{ */ + +/* ISO C definitions */ +#define l_gmtime(t,r) ((void)(r)->tm_sec, gmtime(t)) +#define l_localtime(t,r) ((void)(r)->tm_sec, localtime(t)) + +#endif /* } */ + +#endif /* } */ + +/* }================================================================== */ + + +/* +** {================================================================== +** Configuration for 'tmpnam': +** By default, Lua uses tmpnam except when POSIX is available, where +** it uses mkstemp. +** =================================================================== +*/ +#if !defined(lua_tmpnam) /* { */ + +#if defined(LUA_USE_POSIX) /* { */ + +#include -#define l_gmtime(t,r) ((void)r, gmtime(t)) -#define l_localtime(t,r) ((void)r, localtime(t)) +#define LUA_TMPNAMBUFSIZE 32 +#if !defined(LUA_TMPNAMTEMPLATE) +#define LUA_TMPNAMTEMPLATE "/tmp/lua_XXXXXX" #endif +#define lua_tmpnam(b,e) { \ + strcpy(b, LUA_TMPNAMTEMPLATE); \ + e = mkstemp(b); \ + if (e != -1) close(e); \ + e = (e == -1); } + +#else /* }{ */ + +/* ISO C definitions */ +#define LUA_TMPNAMBUFSIZE L_tmpnam +#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } + +#endif /* } */ + +#endif /* } */ +/* }================================================================== */ + + static int os_execute (lua_State *L) { @@ -145,45 +206,68 @@ static void setboolfield (lua_State *L, const char *key, int value) { lua_setfield(L, -2, key); } + +/* +** Set all fields from structure 'tm' in the table on top of the stack +*/ +static void setallfields (lua_State *L, struct tm *stm) { + setfield(L, "sec", stm->tm_sec); + setfield(L, "min", stm->tm_min); + setfield(L, "hour", stm->tm_hour); + setfield(L, "day", stm->tm_mday); + setfield(L, "month", stm->tm_mon + 1); + setfield(L, "year", stm->tm_year + 1900); + setfield(L, "wday", stm->tm_wday + 1); + setfield(L, "yday", stm->tm_yday + 1); + setboolfield(L, "isdst", stm->tm_isdst); +} + + static int getboolfield (lua_State *L, const char *key) { int res; - lua_getfield(L, -1, key); - res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1); + res = (lua_getfield(L, -1, key) == LUA_TNIL) ? -1 : lua_toboolean(L, -1); lua_pop(L, 1); return res; } -static int getfield (lua_State *L, const char *key, int d) { - int res, isnum; - lua_getfield(L, -1, key); - res = (int)lua_tointegerx(L, -1, &isnum); - if (!isnum) { - if (d < 0) - return luaL_error(L, "field " LUA_QS " missing in date table", key); +/* maximum value for date fields (to avoid arithmetic overflows with 'int') */ +#if !defined(L_MAXDATEFIELD) +#define L_MAXDATEFIELD (INT_MAX / 2) +#endif + +static int getfield (lua_State *L, const char *key, int d, int delta) { + int isnum; + int t = lua_getfield(L, -1, key); /* get field and its type */ + lua_Integer res = lua_tointegerx(L, -1, &isnum); + if (!isnum) { /* field is not an integer? */ + if (t != LUA_TNIL) /* some other value? */ + return luaL_error(L, "field '%s' is not an integer", key); + else if (d < 0) /* absent field; no default? */ + return luaL_error(L, "field '%s' missing in date table", key); res = d; } + else { + if (!(-L_MAXDATEFIELD <= res && res <= L_MAXDATEFIELD)) + return luaL_error(L, "field '%s' is out-of-bound", key); + res -= delta; + } lua_pop(L, 1); - return res; + return (int)res; } -static const char *checkoption (lua_State *L, const char *conv, char *buff) { - static const char *const options[] = LUA_STRFTIMEOPTIONS; - unsigned int i; - for (i = 0; i < sizeof(options)/sizeof(options[0]); i += 2) { - if (*conv != '\0' && strchr(options[i], *conv) != NULL) { - buff[1] = *conv; - if (*options[i + 1] == '\0') { /* one-char conversion specifier? */ - buff[2] = '\0'; /* end buffer */ - return conv + 1; - } - else if (*(conv + 1) != '\0' && - strchr(options[i + 1], *(conv + 1)) != NULL) { - buff[2] = *(conv + 1); /* valid two-char conversion specifier */ - buff[3] = '\0'; /* end buffer */ - return conv + 2; - } +static const char *checkoption (lua_State *L, const char *conv, + ptrdiff_t convlen, char *buff) { + const char *option = LUA_STRFTIMEOPTIONS; + int oplen = 1; /* length of options being checked */ + for (; *option != '\0' && oplen <= convlen; option += oplen) { + if (*option == '|') /* next block? */ + oplen++; /* will check options with next length (+1) */ + else if (memcmp(conv, option, oplen) == 0) { /* match? */ + memcpy(buff, conv, oplen); /* copy valid option to buffer */ + buff[oplen] = '\0'; + return conv + oplen; /* return next item */ } } luaL_argerror(L, 1, @@ -192,44 +276,44 @@ static const char *checkoption (lua_State *L, const char *conv, char *buff) { } +/* maximum size for an individual 'strftime' item */ +#define SIZETIMEFMT 250 + + static int os_date (lua_State *L) { - const char *s = luaL_optstring(L, 1, "%c"); - time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL)); + size_t slen; + const char *s = luaL_optlstring(L, 1, "%c", &slen); + time_t t = luaL_opt(L, l_checktime, 2, time(NULL)); + const char *se = s + slen; /* 's' end */ struct tm tmr, *stm; if (*s == '!') { /* UTC? */ stm = l_gmtime(&t, &tmr); - s++; /* skip `!' */ + s++; /* skip '!' */ } else stm = l_localtime(&t, &tmr); if (stm == NULL) /* invalid date? */ - lua_pushnil(L); - else if (strcmp(s, "*t") == 0) { + return luaL_error(L, + "time result cannot be represented in this installation"); + if (strcmp(s, "*t") == 0) { lua_createtable(L, 0, 9); /* 9 = number of fields */ - setfield(L, "sec", stm->tm_sec); - setfield(L, "min", stm->tm_min); - setfield(L, "hour", stm->tm_hour); - setfield(L, "day", stm->tm_mday); - setfield(L, "month", stm->tm_mon+1); - setfield(L, "year", stm->tm_year+1900); - setfield(L, "wday", stm->tm_wday+1); - setfield(L, "yday", stm->tm_yday+1); - setboolfield(L, "isdst", stm->tm_isdst); + setallfields(L, stm); } else { - char cc[4]; + char cc[4]; /* buffer for individual conversion specifiers */ luaL_Buffer b; cc[0] = '%'; luaL_buffinit(L, &b); - while (*s) { - if (*s != '%') /* no conversion specifier? */ + while (s < se) { + if (*s != '%') /* not a conversion specifier? */ luaL_addchar(&b, *s++); else { size_t reslen; - char buff[200]; /* should be big enough for any conversion result */ - s = checkoption(L, s + 1, cc); - reslen = strftime(buff, sizeof(buff), cc, stm); - luaL_addlstring(&b, buff, reslen); + char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT); + s++; /* skip '%' */ + s = checkoption(L, s, se - s, cc + 1); /* copy specifier to 'cc' */ + reslen = strftime(buff, SIZETIMEFMT, cc, stm); + luaL_addsize(&b, reslen); } } luaL_pushresult(&b); @@ -246,26 +330,28 @@ static int os_time (lua_State *L) { struct tm ts; luaL_checktype(L, 1, LUA_TTABLE); lua_settop(L, 1); /* make sure table is at the top */ - ts.tm_sec = getfield(L, "sec", 0); - ts.tm_min = getfield(L, "min", 0); - ts.tm_hour = getfield(L, "hour", 12); - ts.tm_mday = getfield(L, "day", -1); - ts.tm_mon = getfield(L, "month", -1) - 1; - ts.tm_year = getfield(L, "year", -1) - 1900; + ts.tm_sec = getfield(L, "sec", 0, 0); + ts.tm_min = getfield(L, "min", 0, 0); + ts.tm_hour = getfield(L, "hour", 12, 0); + ts.tm_mday = getfield(L, "day", -1, 0); + ts.tm_mon = getfield(L, "month", -1, 1); + ts.tm_year = getfield(L, "year", -1, 1900); ts.tm_isdst = getboolfield(L, "isdst"); t = mktime(&ts); + setallfields(L, &ts); /* update fields with normalized values */ } - if (t == (time_t)(-1)) - lua_pushnil(L); - else - lua_pushnumber(L, (lua_Number)t); + if (t != (time_t)(l_timet)t || t == (time_t)(-1)) + return luaL_error(L, + "time result cannot be represented in this installation"); + l_pushtime(L, t); return 1; } static int os_difftime (lua_State *L) { - lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)), - (time_t)(luaL_optnumber(L, 2, 0)))); + time_t t1 = l_checktime(L, 1); + time_t t2 = l_checktime(L, 2); + lua_pushnumber(L, (lua_Number)difftime(t1, t2)); return 1; } @@ -289,7 +375,7 @@ static int os_exit (lua_State *L) { if (lua_isboolean(L, 1)) status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE); else - status = luaL_optint(L, 1, EXIT_SUCCESS); + status = (int)luaL_optinteger(L, 1, EXIT_SUCCESS); if (lua_toboolean(L, 2)) lua_close(L); if (L) exit(status); /* 'if' to avoid warnings for unreachable 'return' */ diff --git a/depends/lua/src/lparser.c b/depends/lua/src/lparser.c index 9e1a9ca2cf..2f41e00b80 100644 --- a/depends/lua/src/lparser.c +++ b/depends/lua/src/lparser.c @@ -1,15 +1,17 @@ /* -** $Id: lparser.c,v 2.130.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lparser.c,v 2.155.1.2 2017/04/29 18:11:40 roberto Exp $ ** Lua Parser ** See Copyright Notice in lua.h */ - -#include - #define lparser_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" #include "lcode.h" @@ -35,17 +37,21 @@ #define hasmultret(k) ((k) == VCALL || (k) == VVARARG) +/* because all strings are unified by the scanner, the parser + can use pointer equality for string equality */ +#define eqstr(a,b) ((a) == (b)) + /* ** nodes for block list (list of active blocks) */ typedef struct BlockCnt { struct BlockCnt *previous; /* chain */ - short firstlabel; /* index of first label in this block */ - short firstgoto; /* index of first pending goto in this block */ + int firstlabel; /* index of first label in this block */ + int firstgoto; /* index of first pending goto in this block */ lu_byte nactvar; /* # active locals outside the block */ lu_byte upval; /* true if some variable in the block is an upvalue */ - lu_byte isloop; /* true if `block' is a loop */ + lu_byte isloop; /* true if 'block' is a loop */ } BlockCnt; @@ -57,19 +63,9 @@ static void statement (LexState *ls); static void expr (LexState *ls, expdesc *v); -static void anchor_token (LexState *ls) { - /* last token from outer function must be EOS */ - lua_assert(ls->fs != NULL || ls->t.token == TK_EOS); - if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) { - TString *ts = ls->t.seminfo.ts; - luaX_newstring(ls, getstr(ts), ts->tsv.len); - } -} - - /* semantic error */ static l_noret semerror (LexState *ls, const char *msg) { - ls->t.token = 0; /* remove 'near to' from final message */ + ls->t.token = 0; /* remove "near " from final message */ luaX_syntaxerror(ls, msg); } @@ -168,7 +164,8 @@ static int registerlocalvar (LexState *ls, TString *varname) { int oldsize = f->sizelocvars; luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars, LocVar, SHRT_MAX, "local variables"); - while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL; + while (oldsize < f->sizelocvars) + f->locvars[oldsize++].varname = NULL; f->locvars[fs->nlocvars].varname = varname; luaC_objbarrier(ls->L, f, varname); return fs->nlocvars++; @@ -222,7 +219,7 @@ static int searchupvalue (FuncState *fs, TString *name) { int i; Upvaldesc *up = fs->f->upvalues; for (i = 0; i < fs->nups; i++) { - if (luaS_eqstr(up[i].name, name)) return i; + if (eqstr(up[i].name, name)) return i; } return -1; /* not found */ } @@ -234,7 +231,8 @@ static int newupvalue (FuncState *fs, TString *name, expdesc *v) { checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, Upvaldesc, MAXUPVAL, "upvalues"); - while (oldsize < f->sizeupvalues) f->upvalues[oldsize++].name = NULL; + while (oldsize < f->sizeupvalues) + f->upvalues[oldsize++].name = NULL; f->upvalues[fs->nups].instack = (v->k == VLOCAL); f->upvalues[fs->nups].idx = cast_byte(v->u.info); f->upvalues[fs->nups].name = name; @@ -246,7 +244,7 @@ static int newupvalue (FuncState *fs, TString *name, expdesc *v) { static int searchvar (FuncState *fs, TString *n) { int i; for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { - if (luaS_eqstr(n, getlocvar(fs, i)->varname)) + if (eqstr(n, getlocvar(fs, i)->varname)) return i; } return -1; /* not found */ @@ -259,7 +257,8 @@ static int searchvar (FuncState *fs, TString *n) { */ static void markupval (FuncState *fs, int level) { BlockCnt *bl = fs->bl; - while (bl->nactvar > level) bl = bl->previous; + while (bl->nactvar > level) + bl = bl->previous; bl->upval = 1; } @@ -268,27 +267,26 @@ static void markupval (FuncState *fs, int level) { Find variable with given name 'n'. If it is an upvalue, add this upvalue into all intermediate functions. */ -static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { +static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { if (fs == NULL) /* no more levels? */ - return VVOID; /* default is global */ + init_exp(var, VVOID, 0); /* default is global */ else { int v = searchvar(fs, n); /* look up locals at current level */ if (v >= 0) { /* found? */ init_exp(var, VLOCAL, v); /* variable is local */ if (!base) markupval(fs, v); /* local will be used as an upval */ - return VLOCAL; } else { /* not found as local at current level; try upvalues */ int idx = searchupvalue(fs, n); /* try existing upvalues */ if (idx < 0) { /* not found? */ - if (singlevaraux(fs->prev, n, var, 0) == VVOID) /* try upper levels */ - return VVOID; /* not found; is a global */ + singlevaraux(fs->prev, n, var, 0); /* try upper levels */ + if (var->k == VVOID) /* not found? */ + return; /* it is a global */ /* else was LOCAL or UPVAL */ idx = newupvalue(fs, n, var); /* will be a new upvalue */ } - init_exp(var, VUPVAL, idx); - return VUPVAL; + init_exp(var, VUPVAL, idx); /* new or old upvalue */ } } } @@ -297,10 +295,11 @@ static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { static void singlevar (LexState *ls, expdesc *var) { TString *varname = str_checkname(ls); FuncState *fs = ls->fs; - if (singlevaraux(fs, varname, var, 1) == VVOID) { /* global name? */ + singlevaraux(fs, varname, var, 1); + if (var->k == VVOID) { /* global name? */ expdesc key; singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ - lua_assert(var->k == VLOCAL || var->k == VUPVAL); + lua_assert(var->k != VVOID); /* this one must exist */ codestring(ls, &key, varname); /* key is variable name */ luaK_indexed(fs, var, &key); /* env[varname] */ } @@ -324,6 +323,8 @@ static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { luaK_nil(fs, reg, extra); } } + if (nexps > nvars) + ls->fs->freereg -= nexps - nvars; /* remove extra values */ } @@ -342,11 +343,11 @@ static void closegoto (LexState *ls, int g, Labeldesc *label) { FuncState *fs = ls->fs; Labellist *gl = &ls->dyd->gt; Labeldesc *gt = &gl->arr[g]; - lua_assert(luaS_eqstr(gt->name, label->name)); + lua_assert(eqstr(gt->name, label->name)); if (gt->nactvar < label->nactvar) { TString *vname = getlocvar(fs, gt->nactvar)->varname; const char *msg = luaO_pushfstring(ls->L, - " at line %d jumps into the scope of local " LUA_QS, + " at line %d jumps into the scope of local '%s'", getstr(gt->name), gt->line, getstr(vname)); semerror(ls, msg); } @@ -369,7 +370,7 @@ static int findlabel (LexState *ls, int g) { /* check labels in current block for a match */ for (i = bl->firstlabel; i < dyd->label.n; i++) { Labeldesc *lb = &dyd->label.arr[i]; - if (luaS_eqstr(lb->name, gt->name)) { /* correct label? */ + if (eqstr(lb->name, gt->name)) { /* correct label? */ if (gt->nactvar > lb->nactvar && (bl->upval || dyd->label.n > bl->firstlabel)) luaK_patchclose(ls->fs, gt->pc, lb->nactvar); @@ -390,7 +391,7 @@ static int newlabelentry (LexState *ls, Labellist *l, TString *name, l->arr[n].line = line; l->arr[n].nactvar = ls->fs->nactvar; l->arr[n].pc = pc; - l->n++; + l->n = n + 1; return n; } @@ -403,7 +404,7 @@ static void findgotos (LexState *ls, Labeldesc *lb) { Labellist *gl = &ls->dyd->gt; int i = ls->fs->bl->firstgoto; while (i < gl->n) { - if (luaS_eqstr(gl->arr[i].name, lb->name)) + if (eqstr(gl->arr[i].name, lb->name)) closegoto(ls, i, lb); else i++; @@ -412,7 +413,7 @@ static void findgotos (LexState *ls, Labeldesc *lb) { /* -** "export" pending gotos to outer level, to check them against +** export pending gotos to outer level, to check them against ** outer labels; if the block being exited has upvalues, and ** the goto exits the scope of any variable (which can be the ** upvalue), close those variables being exited. @@ -448,7 +449,7 @@ static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { /* -** create a label named "break" to resolve break statements +** create a label named 'break' to resolve break statements */ static void breaklabel (LexState *ls) { TString *n = luaS_new(ls->L, "break"); @@ -463,7 +464,7 @@ static void breaklabel (LexState *ls) { static l_noret undefgoto (LexState *ls, Labeldesc *gt) { const char *msg = isreserved(gt->name) ? "<%s> at line %d not inside a loop" - : "no visible label " LUA_QS " for at line %d"; + : "no visible label '%s' for at line %d"; msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line); semerror(ls, msg); } @@ -503,7 +504,8 @@ static Proto *addprototype (LexState *ls) { if (fs->np >= f->sizep) { int oldsize = f->sizep; luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions"); - while (oldsize < f->sizep) f->p[oldsize++] = NULL; + while (oldsize < f->sizep) + f->p[oldsize++] = NULL; } f->p[fs->np++] = clp = luaF_newproto(L); luaC_objbarrier(L, f, clp); @@ -525,7 +527,6 @@ static void codeclosure (LexState *ls, expdesc *v) { static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { - lua_State *L = ls->L; Proto *f; fs->prev = ls->fs; /* linked list of funcstates */ fs->ls = ls; @@ -543,11 +544,8 @@ static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { fs->bl = NULL; f = fs->f; f->source = ls->source; + luaC_objbarrier(ls->L, f, f->source); f->maxstacksize = 2; /* registers 0/1 are always valid */ - fs->h = luaH_new(L); - /* anchor table of constants (to avoid being collected) */ - sethvalue2s(L, L->top, fs->h); - incr_top(L); enterblock(fs, bl, 0); } @@ -572,9 +570,6 @@ static void close_func (LexState *ls) { f->sizeupvalues = fs->nups; lua_assert(fs->bl == NULL); ls->fs = fs->prev; - /* last token read was anchored in defunct function; must re-anchor it */ - anchor_token(ls); - L->top--; /* pop table of constants */ luaC_checkGC(L); } @@ -588,7 +583,7 @@ static void close_func (LexState *ls) { /* ** check whether current token is in the follow set of a block. ** 'until' closes syntactical blocks, but do not close scope, -** so it handled in separate. +** so it is handled in separate. */ static int block_follow (LexState *ls, int withuntil) { switch (ls->t.token) { @@ -602,7 +597,7 @@ static int block_follow (LexState *ls, int withuntil) { static void statlist (LexState *ls) { - /* statlist -> { stat [`;'] } */ + /* statlist -> { stat [';'] } */ while (!block_follow(ls, 1)) { if (ls->t.token == TK_RETURN) { statement(ls); @@ -643,14 +638,14 @@ static void yindex (LexState *ls, expdesc *v) { struct ConsControl { expdesc v; /* last list item read */ expdesc *t; /* table descriptor */ - int nh; /* total number of `record' elements */ + int nh; /* total number of 'record' elements */ int na; /* total number of array elements */ int tostore; /* number of array elements pending to be stored */ }; static void recfield (LexState *ls, struct ConsControl *cc) { - /* recfield -> (NAME | `['exp1`]') = exp1 */ + /* recfield -> (NAME | '['exp1']') = exp1 */ FuncState *fs = ls->fs; int reg = ls->fs->freereg; expdesc key, val; @@ -757,12 +752,12 @@ static void constructor (LexState *ls, expdesc *t) { static void parlist (LexState *ls) { - /* parlist -> [ param { `,' param } ] */ + /* parlist -> [ param { ',' param } ] */ FuncState *fs = ls->fs; Proto *f = fs->f; int nparams = 0; f->is_vararg = 0; - if (ls->t.token != ')') { /* is `parlist' not empty? */ + if (ls->t.token != ')') { /* is 'parlist' not empty? */ do { switch (ls->t.token) { case TK_NAME: { /* param -> NAME */ @@ -770,12 +765,12 @@ static void parlist (LexState *ls) { nparams++; break; } - case TK_DOTS: { /* param -> `...' */ + case TK_DOTS: { /* param -> '...' */ luaX_next(ls); - f->is_vararg = 1; + f->is_vararg = 1; /* declared vararg */ break; } - default: luaX_syntaxerror(ls, " or " LUA_QL("...") " expected"); + default: luaX_syntaxerror(ls, " or '...' expected"); } } while (!f->is_vararg && testnext(ls, ',')); } @@ -786,7 +781,7 @@ static void parlist (LexState *ls) { static void body (LexState *ls, expdesc *e, int ismethod, int line) { - /* body -> `(' parlist `)' block END */ + /* body -> '(' parlist ')' block END */ FuncState new_fs; BlockCnt bl; new_fs.f = addprototype(ls); @@ -808,7 +803,7 @@ static void body (LexState *ls, expdesc *e, int ismethod, int line) { static int explist (LexState *ls, expdesc *v) { - /* explist -> expr { `,' expr } */ + /* explist -> expr { ',' expr } */ int n = 1; /* at least one expression */ expr(ls, v); while (testnext(ls, ',')) { @@ -825,7 +820,7 @@ static void funcargs (LexState *ls, expdesc *f, int line) { expdesc args; int base, nparams; switch (ls->t.token) { - case '(': { /* funcargs -> `(' [ explist ] `)' */ + case '(': { /* funcargs -> '(' [ explist ] ')' */ luaX_next(ls); if (ls->t.token == ')') /* arg list is empty? */ args.k = VVOID; @@ -842,7 +837,7 @@ static void funcargs (LexState *ls, expdesc *f, int line) { } case TK_STRING: { /* funcargs -> STRING */ codestring(ls, &args, ls->t.seminfo.ts); - luaX_next(ls); /* must use `seminfo' before `next' */ + luaX_next(ls); /* must use 'seminfo' before 'next' */ break; } default: { @@ -908,14 +903,14 @@ static void suffixedexp (LexState *ls, expdesc *v) { fieldsel(ls, v); break; } - case '[': { /* `[' exp1 `]' */ + case '[': { /* '[' exp1 ']' */ expdesc key; luaK_exp2anyregup(fs, v); yindex(ls, &key); luaK_indexed(fs, v, &key); break; } - case ':': { /* `:' NAME funcargs */ + case ':': { /* ':' NAME funcargs */ expdesc key; luaX_next(ls); checkname(ls, &key); @@ -935,14 +930,19 @@ static void suffixedexp (LexState *ls, expdesc *v) { static void simpleexp (LexState *ls, expdesc *v) { - /* simpleexp -> NUMBER | STRING | NIL | TRUE | FALSE | ... | + /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... | constructor | FUNCTION body | suffixedexp */ switch (ls->t.token) { - case TK_NUMBER: { - init_exp(v, VKNUM, 0); + case TK_FLT: { + init_exp(v, VKFLT, 0); v->u.nval = ls->t.seminfo.r; break; } + case TK_INT: { + init_exp(v, VKINT, 0); + v->u.ival = ls->t.seminfo.i; + break; + } case TK_STRING: { codestring(ls, v, ls->t.seminfo.ts); break; @@ -962,7 +962,7 @@ static void simpleexp (LexState *ls, expdesc *v) { case TK_DOTS: { /* vararg */ FuncState *fs = ls->fs; check_condition(ls, fs->f->is_vararg, - "cannot use " LUA_QL("...") " outside a vararg function"); + "cannot use '...' outside a vararg function"); init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0)); break; } @@ -988,6 +988,7 @@ static UnOpr getunopr (int op) { switch (op) { case TK_NOT: return OPR_NOT; case '-': return OPR_MINUS; + case '~': return OPR_BNOT; case '#': return OPR_LEN; default: return OPR_NOUNOPR; } @@ -999,9 +1000,15 @@ static BinOpr getbinopr (int op) { case '+': return OPR_ADD; case '-': return OPR_SUB; case '*': return OPR_MUL; - case '/': return OPR_DIV; case '%': return OPR_MOD; case '^': return OPR_POW; + case '/': return OPR_DIV; + case TK_IDIV: return OPR_IDIV; + case '&': return OPR_BAND; + case '|': return OPR_BOR; + case '~': return OPR_BXOR; + case TK_SHL: return OPR_SHL; + case TK_SHR: return OPR_SHR; case TK_CONCAT: return OPR_CONCAT; case TK_NE: return OPR_NE; case TK_EQ: return OPR_EQ; @@ -1020,19 +1027,24 @@ static const struct { lu_byte left; /* left priority for each binary operator */ lu_byte right; /* right priority */ } priority[] = { /* ORDER OPR */ - {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, /* `+' `-' `*' `/' `%' */ - {10, 9}, {5, 4}, /* ^, .. (right associative) */ - {3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */ - {3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */ - {2, 2}, {1, 1} /* and, or */ + {10, 10}, {10, 10}, /* '+' '-' */ + {11, 11}, {11, 11}, /* '*' '%' */ + {14, 13}, /* '^' (right associative) */ + {11, 11}, {11, 11}, /* '/' '//' */ + {6, 6}, {4, 4}, {5, 5}, /* '&' '|' '~' */ + {7, 7}, {7, 7}, /* '<<' '>>' */ + {9, 8}, /* '..' (right associative) */ + {3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */ + {3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */ + {2, 2}, {1, 1} /* and, or */ }; -#define UNARY_PRIORITY 8 /* priority for unary operators */ +#define UNARY_PRIORITY 12 /* priority for unary operators */ /* ** subexpr -> (simpleexp | unop subexpr) { binop subexpr } -** where `binop' is any binary operator with a priority higher than `limit' +** where 'binop' is any binary operator with a priority higher than 'limit' */ static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { BinOpr op; @@ -1046,7 +1058,7 @@ static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { luaK_prefix(ls->fs, uop, v, line); } else simpleexp(ls, v); - /* expand while operators have priorities higher than `limit' */ + /* expand while operators have priorities higher than 'limit' */ op = getbinopr(ls->t.token); while (op != OPR_NOBINOPR && priority[op].left > limit) { expdesc v2; @@ -1146,15 +1158,12 @@ static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { "C levels"); assignment(ls, &nv, nvars+1); } - else { /* assignment -> `=' explist */ + else { /* assignment -> '=' explist */ int nexps; checknext(ls, '='); nexps = explist(ls, &e); - if (nexps != nvars) { + if (nexps != nvars) adjust_assign(ls, nvars, nexps, &e); - if (nexps > nvars) - ls->fs->freereg -= nexps - nvars; /* remove extra values */ - } else { luaK_setoneret(ls->fs, &e); /* close last expression */ luaK_storevar(ls->fs, &lh->v, &e); @@ -1170,7 +1179,7 @@ static int cond (LexState *ls) { /* cond -> exp */ expdesc v; expr(ls, &v); /* read condition */ - if (v.k == VNIL) v.k = VFALSE; /* `falses' are all equal here */ + if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */ luaK_goiftrue(ls->fs, &v); return v.f; } @@ -1195,9 +1204,9 @@ static void gotostat (LexState *ls, int pc) { static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) { int i; for (i = fs->bl->firstlabel; i < ll->n; i++) { - if (luaS_eqstr(label, ll->arr[i].name)) { + if (eqstr(label, ll->arr[i].name)) { const char *msg = luaO_pushfstring(fs->ls->L, - "label " LUA_QS " already defined on line %d", + "label '%s' already defined on line %d", getstr(label), ll->arr[i].line); semerror(fs->ls, msg); } @@ -1220,7 +1229,7 @@ static void labelstat (LexState *ls, TString *label, int line) { checkrepeated(fs, ll, label); /* check for repeated labels */ checknext(ls, TK_DBCOLON); /* skip double colon */ /* create new entry for this label */ - l = newlabelentry(ls, ll, label, line, fs->pc); + l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs)); skipnoopstat(ls); /* skip other no-op statements */ if (block_follow(ls, 0)) { /* label is last no-op statement in the block? */ /* assume that locals are already out of scope */ @@ -1321,7 +1330,7 @@ static void fornum (LexState *ls, TString *varname, int line) { if (testnext(ls, ',')) exp1(ls); /* optional step */ else { /* default step = 1 */ - luaK_codek(fs, fs->freereg, luaK_numberK(fs, 1)); + luaK_codek(fs, fs->freereg, luaK_intK(fs, 1)); luaK_reserveregs(fs, 1); } forbody(ls, base, line, 1, 1); @@ -1359,15 +1368,15 @@ static void forstat (LexState *ls, int line) { TString *varname; BlockCnt bl; enterblock(fs, &bl, 1); /* scope for loop and control variables */ - luaX_next(ls); /* skip `for' */ + luaX_next(ls); /* skip 'for' */ varname = str_checkname(ls); /* first variable name */ switch (ls->t.token) { case '=': fornum(ls, varname, line); break; case ',': case TK_IN: forlist(ls, varname); break; - default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected"); + default: luaX_syntaxerror(ls, "'=' or 'in' expected"); } check_match(ls, TK_END, TK_FOR, line); - leaveblock(fs); /* loop scope (`break' jumps to this point) */ + leaveblock(fs); /* loop scope ('break' jumps to this point) */ } @@ -1384,7 +1393,7 @@ static void test_then_block (LexState *ls, int *escapelist) { luaK_goiffalse(ls->fs, &v); /* will jump to label if condition is true */ enterblock(fs, &bl, 0); /* must enter block before 'goto' */ gotostat(ls, v.t); /* handle goto/break */ - skipnoopstat(ls); /* skip other no-op statements */ + while (testnext(ls, ';')) {} /* skip colons */ if (block_follow(ls, 0)) { /* 'goto' is the entire block? */ leaveblock(fs); return; /* and that is it */ @@ -1397,7 +1406,7 @@ static void test_then_block (LexState *ls, int *escapelist) { enterblock(fs, &bl, 0); jf = v.f; } - statlist(ls); /* `then' part */ + statlist(ls); /* 'then' part */ leaveblock(fs); if (ls->t.token == TK_ELSE || ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */ @@ -1414,7 +1423,7 @@ static void ifstat (LexState *ls, int line) { while (ls->t.token == TK_ELSEIF) test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */ if (testnext(ls, TK_ELSE)) - block(ls); /* `else' part */ + block(ls); /* 'else' part */ check_match(ls, TK_END, TK_IF, line); luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */ } @@ -1432,7 +1441,7 @@ static void localfunc (LexState *ls) { static void localstat (LexState *ls) { - /* stat -> LOCAL NAME {`,' NAME} [`=' explist] */ + /* stat -> LOCAL NAME {',' NAME} ['=' explist] */ int nvars = 0; int nexps; expdesc e; @@ -1452,7 +1461,7 @@ static void localstat (LexState *ls) { static int funcname (LexState *ls, expdesc *v) { - /* funcname -> NAME {fieldsel} [`:' NAME] */ + /* funcname -> NAME {fieldsel} [':' NAME] */ int ismethod = 0; singlevar(ls, v); while (ls->t.token == '.') @@ -1473,7 +1482,7 @@ static void funcstat (LexState *ls, int line) { ismethod = funcname(ls, &v); body(ls, &b, ismethod, line); luaK_storevar(ls->fs, &v, &b); - luaK_fixline(ls->fs, line); /* definition `happens' in the first line */ + luaK_fixline(ls->fs, line); /* definition "happens" in the first line */ } @@ -1488,7 +1497,7 @@ static void exprstat (LexState *ls) { } else { /* stat -> func */ check_condition(ls, v.v.k == VCALL, "syntax error"); - SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */ + SETARG_C(getinstruction(fs, &v.v), 1); /* call statement uses no results */ } } @@ -1505,8 +1514,8 @@ static void retstat (LexState *ls) { if (hasmultret(e.k)) { luaK_setmultret(fs, &e); if (e.k == VCALL && nret == 1) { /* tail call? */ - SET_OPCODE(getcode(fs,&e), OP_TAILCALL); - lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar); + SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL); + lua_assert(GETARG_A(getinstruction(fs,&e)) == fs->nactvar); } first = fs->nactvar; nret = LUA_MULTRET; /* return all values */ @@ -1515,8 +1524,8 @@ static void retstat (LexState *ls) { if (nret == 1) /* only one single value? */ first = luaK_exp2anyreg(fs, &e); else { - luaK_exp2nextreg(fs, &e); /* values must go to the `stack' */ - first = fs->nactvar; /* return all `active' values */ + luaK_exp2nextreg(fs, &e); /* values must go to the stack */ + first = fs->nactvar; /* return all active values */ lua_assert(nret == fs->freereg - first); } } @@ -1605,9 +1614,10 @@ static void mainfunc (LexState *ls, FuncState *fs) { BlockCnt bl; expdesc v; open_func(ls, fs, &bl); - fs->f->is_vararg = 1; /* main function is always vararg */ + fs->f->is_vararg = 1; /* main function is always declared vararg */ init_exp(&v, VLOCAL, 0); /* create and... */ newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */ + luaC_objbarrier(ls->L, fs->f, ls->envn); luaX_next(ls); /* read first token */ statlist(ls); /* parse main body */ check(ls, TK_EOS); @@ -1615,16 +1625,20 @@ static void mainfunc (LexState *ls, FuncState *fs) { } -Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, - Dyndata *dyd, const char *name, int firstchar) { +LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, + Dyndata *dyd, const char *name, int firstchar) { LexState lexstate; FuncState funcstate; - Closure *cl = luaF_newLclosure(L, 1); /* create main closure */ - /* anchor closure (to avoid being collected) */ - setclLvalue(L, L->top, cl); - incr_top(L); - funcstate.f = cl->l.p = luaF_newproto(L); + LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */ + setclLvalue(L, L->top, cl); /* anchor it (to avoid being collected) */ + luaD_inctop(L); + lexstate.h = luaH_new(L); /* create table for scanner */ + sethvalue(L, L->top, lexstate.h); /* anchor it */ + luaD_inctop(L); + funcstate.f = cl->p = luaF_newproto(L); + luaC_objbarrier(L, cl, cl->p); funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ + lua_assert(iswhite(funcstate.f)); /* do not need barrier here */ lexstate.buff = buff; lexstate.dyd = dyd; dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; @@ -1633,6 +1647,7 @@ Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); /* all scopes should be correctly finished */ lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); - return cl; /* it's on the stack too */ + L->top--; /* remove scanner's table */ + return cl; /* closure is on the stack, too */ } diff --git a/depends/lua/src/lstate.c b/depends/lua/src/lstate.c index c7f2672be7..c1a76643c3 100644 --- a/depends/lua/src/lstate.c +++ b/depends/lua/src/lstate.c @@ -1,16 +1,18 @@ /* -** $Id: lstate.c,v 2.99.1.2 2013/11/08 17:45:31 roberto Exp $ +** $Id: lstate.c,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $ ** Global State ** See Copyright Notice in lua.h */ +#define lstate_c +#define LUA_CORE + +#include "lprefix.h" + #include #include -#define lstate_c -#define LUA_CORE - #include "lua.h" #include "lapi.h" @@ -30,18 +32,11 @@ #define LUAI_GCPAUSE 200 /* 200% */ #endif -#if !defined(LUAI_GCMAJOR) -#define LUAI_GCMAJOR 200 /* 200% */ -#endif - #if !defined(LUAI_GCMUL) #define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */ #endif -#define MEMERRMSG "not enough memory" - - /* ** a macro to help the creation of a unique random seed when a state is ** created; the seed is used to randomize hashes. @@ -57,9 +52,7 @@ ** thread state + extra space */ typedef struct LX { -#if defined(LUAI_EXTRASPACE) - char buff[LUAI_EXTRASPACE]; -#endif + lu_byte extra_[LUA_EXTRASPACE]; lua_State l; } LX; @@ -78,13 +71,12 @@ typedef struct LG { /* -** Compute an initial seed as random as possible. In ANSI, rely on -** Address Space Layout Randomization (if present) to increase -** randomness.. +** Compute an initial seed as random as possible. Rely on Address Space +** Layout Randomization (if present) to increase randomness.. */ #define addbuff(b,p,e) \ { size_t t = cast(size_t, e); \ - memcpy(buff + p, &t, sizeof(t)); p += sizeof(t); } + memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } static unsigned int makeseed (lua_State *L) { char buff[4 * sizeof(size_t)]; @@ -101,10 +93,14 @@ static unsigned int makeseed (lua_State *L) { /* ** set GCdebt to a new value keeping the value (totalbytes + GCdebt) -** invariant +** invariant (and avoiding underflows in 'totalbytes') */ void luaE_setdebt (global_State *g, l_mem debt) { - g->totalbytes -= (debt - g->GCdebt); + l_mem tb = gettotalbytes(g); + lua_assert(tb > 0); + if (debt < tb - MAX_LMEM) + debt = tb - MAX_LMEM; /* will make 'totalbytes == MAX_LMEM' */ + g->totalbytes = tb - debt; g->GCdebt = debt; } @@ -115,10 +111,14 @@ CallInfo *luaE_extendCI (lua_State *L) { L->ci->next = ci; ci->previous = L->ci; ci->next = NULL; + L->nci++; return ci; } +/* +** free all CallInfo structures not in use by a thread +*/ void luaE_freeCI (lua_State *L) { CallInfo *ci = L->ci; CallInfo *next = ci->next; @@ -126,6 +126,24 @@ void luaE_freeCI (lua_State *L) { while ((ci = next) != NULL) { next = ci->next; luaM_free(L, ci); + L->nci--; + } +} + + +/* +** free half of the CallInfo structures not in use by a thread +*/ +void luaE_shrinkCI (lua_State *L) { + CallInfo *ci = L->ci; + CallInfo *next2; /* next's next */ + /* while there are two nexts */ + while (ci->next != NULL && (next2 = ci->next->next) != NULL) { + luaM_free(L, ci->next); /* free next */ + L->nci--; + ci->next = next2; /* remove 'next' from the list */ + next2->previous = ci; + ci = next2; /* keep next's next */ } } @@ -155,6 +173,7 @@ static void freestack (lua_State *L) { return; /* stack not completely built yet */ L->ci = &L->base_ci; /* free the entire 'ci' list */ luaE_freeCI(L); + lua_assert(L->nci == 0); luaM_freearray(L, L->stack, L->stacksize); /* free stack array */ } @@ -163,34 +182,32 @@ static void freestack (lua_State *L) { ** Create registry table and its predefined values */ static void init_registry (lua_State *L, global_State *g) { - TValue mt; + TValue temp; /* create registry */ Table *registry = luaH_new(L); sethvalue(L, &g->l_registry, registry); luaH_resize(L, registry, LUA_RIDX_LAST, 0); /* registry[LUA_RIDX_MAINTHREAD] = L */ - setthvalue(L, &mt, L); - luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt); + setthvalue(L, &temp, L); /* temp = L */ + luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &temp); /* registry[LUA_RIDX_GLOBALS] = table of globals */ - sethvalue(L, &mt, luaH_new(L)); - luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt); + sethvalue(L, &temp, luaH_new(L)); /* temp = new table (global table) */ + luaH_setint(L, registry, LUA_RIDX_GLOBALS, &temp); } /* -** open parts of the state that may cause memory-allocation errors +** open parts of the state that may cause memory-allocation errors. +** ('g->version' != NULL flags that the state was completely build) */ static void f_luaopen (lua_State *L, void *ud) { global_State *g = G(L); UNUSED(ud); stack_init(L, L); /* init stack */ init_registry(L, g); - luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ + luaS_init(L); luaT_init(L); luaX_init(L); - /* pre-create memory-error message */ - g->memerrmsg = luaS_newliteral(L, MEMERRMSG); - luaS_fix(g->memerrmsg); /* it should never be collected */ g->gcrunning = 1; /* allow gc */ g->version = lua_version(NULL); luai_userstateopen(L); @@ -198,14 +215,16 @@ static void f_luaopen (lua_State *L, void *ud) { /* -** preinitialize a state with consistent values without allocating +** preinitialize a thread with consistent values without allocating ** any memory (to avoid errors) */ -static void preinit_state (lua_State *L, global_State *g) { +static void preinit_thread (lua_State *L, global_State *g) { G(L) = g; L->stack = NULL; L->ci = NULL; + L->nci = 0; L->stacksize = 0; + L->twups = L; /* thread has no upvalues */ L->errorJmp = NULL; L->nCcalls = 0; L->hook = NULL; @@ -227,7 +246,6 @@ static void close_state (lua_State *L) { if (g->version) /* closing a fully built state? */ luai_userstateclose(L); luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); - luaZ_freebuffer(L, &g->buff); freestack(L); lua_assert(gettotalbytes(g) == sizeof(LG)); (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ @@ -235,17 +253,28 @@ static void close_state (lua_State *L) { LUA_API lua_State *lua_newthread (lua_State *L) { + global_State *g = G(L); lua_State *L1; lua_lock(L); luaC_checkGC(L); - L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th; + /* create new thread */ + L1 = &cast(LX *, luaM_newobject(L, LUA_TTHREAD, sizeof(LX)))->l; + L1->marked = luaC_white(g); + L1->tt = LUA_TTHREAD; + /* link it on list 'allgc' */ + L1->next = g->allgc; + g->allgc = obj2gco(L1); + /* anchor it on L stack */ setthvalue(L, L->top, L1); api_incr_top(L); - preinit_state(L1, G(L)); + preinit_thread(L1, g); L1->hookmask = L->hookmask; L1->basehookcount = L->basehookcount; L1->hook = L->hook; resethookcount(L1); + /* initialize L1 extra space */ + memcpy(lua_getextraspace(L1), lua_getextraspace(g->mainthread), + LUA_EXTRASPACE); luai_userstatethread(L, L1); stack_init(L1, L); /* init stack */ lua_unlock(L); @@ -273,36 +302,31 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { g = &l->g; L->next = NULL; L->tt = LUA_TTHREAD; - g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT); + g->currentwhite = bitmask(WHITE0BIT); L->marked = luaC_white(g); - g->gckind = KGC_NORMAL; - preinit_state(L, g); + preinit_thread(L, g); g->frealloc = f; g->ud = ud; g->mainthread = L; g->seed = makeseed(L); - g->uvhead.u.l.prev = &g->uvhead; - g->uvhead.u.l.next = &g->uvhead; g->gcrunning = 0; /* no GC while building state */ g->GCestimate = 0; - g->strt.size = 0; - g->strt.nuse = 0; + g->strt.size = g->strt.nuse = 0; g->strt.hash = NULL; setnilvalue(&g->l_registry); - luaZ_initbuffer(L, &g->buff); g->panic = NULL; g->version = NULL; g->gcstate = GCSpause; - g->allgc = NULL; - g->finobj = NULL; - g->tobefnz = NULL; - g->sweepgc = g->sweepfin = NULL; + g->gckind = KGC_NORMAL; + g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL; + g->sweepgc = NULL; g->gray = g->grayagain = NULL; g->weak = g->ephemeron = g->allweak = NULL; + g->twups = NULL; g->totalbytes = sizeof(LG); g->GCdebt = 0; + g->gcfinnum = 0; g->gcpause = LUAI_GCPAUSE; - g->gcmajorinc = LUAI_GCMAJOR; g->gcstepmul = LUAI_GCMUL; for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL; if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { diff --git a/depends/lua/src/lstring.c b/depends/lua/src/lstring.c index af96c89c18..6257f211d9 100644 --- a/depends/lua/src/lstring.c +++ b/depends/lua/src/lstring.c @@ -1,23 +1,30 @@ /* -** $Id: lstring.c,v 2.26.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lstring.c,v 2.56.1.1 2017/04/19 17:20:42 roberto Exp $ ** String table (keeps all strings handled by Lua) ** See Copyright Notice in lua.h */ - -#include - #define lstring_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" +#include "ldebug.h" +#include "ldo.h" #include "lmem.h" #include "lobject.h" #include "lstate.h" #include "lstring.h" +#define MEMERRMSG "not enough memory" + + /* ** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to ** compute its hash @@ -31,99 +38,126 @@ ** equality for long strings */ int luaS_eqlngstr (TString *a, TString *b) { - size_t len = a->tsv.len; - lua_assert(a->tsv.tt == LUA_TLNGSTR && b->tsv.tt == LUA_TLNGSTR); + size_t len = a->u.lnglen; + lua_assert(a->tt == LUA_TLNGSTR && b->tt == LUA_TLNGSTR); return (a == b) || /* same instance or... */ - ((len == b->tsv.len) && /* equal length and ... */ + ((len == b->u.lnglen) && /* equal length and ... */ (memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */ } -/* -** equality for strings -*/ -int luaS_eqstr (TString *a, TString *b) { - return (a->tsv.tt == b->tsv.tt) && - (a->tsv.tt == LUA_TSHRSTR ? eqshrstr(a, b) : luaS_eqlngstr(a, b)); -} - - unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) { unsigned int h = seed ^ cast(unsigned int, l); - size_t l1; size_t step = (l >> LUAI_HASHLIMIT) + 1; - for (l1 = l; l1 >= step; l1 -= step) - h = h ^ ((h<<5) + (h>>2) + cast_byte(str[l1 - 1])); + for (; l >= step; l -= step) + h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1])); return h; } +unsigned int luaS_hashlongstr (TString *ts) { + lua_assert(ts->tt == LUA_TLNGSTR); + if (ts->extra == 0) { /* no hash? */ + ts->hash = luaS_hash(getstr(ts), ts->u.lnglen, ts->hash); + ts->extra = 1; /* now it has its hash */ + } + return ts->hash; +} + + /* ** resizes the string table */ void luaS_resize (lua_State *L, int newsize) { int i; stringtable *tb = &G(L)->strt; - /* cannot resize while GC is traversing strings */ - luaC_runtilstate(L, ~bitmask(GCSsweepstring)); - if (newsize > tb->size) { - luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *); - for (i = tb->size; i < newsize; i++) tb->hash[i] = NULL; + if (newsize > tb->size) { /* grow table if needed */ + luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *); + for (i = tb->size; i < newsize; i++) + tb->hash[i] = NULL; } - /* rehash */ - for (i=0; isize; i++) { - GCObject *p = tb->hash[i]; + for (i = 0; i < tb->size; i++) { /* rehash */ + TString *p = tb->hash[i]; tb->hash[i] = NULL; while (p) { /* for each node in the list */ - GCObject *next = gch(p)->next; /* save next */ - unsigned int h = lmod(gco2ts(p)->hash, newsize); /* new position */ - gch(p)->next = tb->hash[h]; /* chain it */ + TString *hnext = p->u.hnext; /* save next */ + unsigned int h = lmod(p->hash, newsize); /* new position */ + p->u.hnext = tb->hash[h]; /* chain it */ tb->hash[h] = p; - resetoldbit(p); /* see MOVE OLD rule */ - p = next; + p = hnext; } } - if (newsize < tb->size) { - /* shrinking slice must be empty */ + if (newsize < tb->size) { /* shrink table if needed */ + /* vanishing slice should be empty */ lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL); - luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *); + luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *); } tb->size = newsize; } +/* +** Clear API string cache. (Entries cannot be empty, so fill them with +** a non-collectable string.) +*/ +void luaS_clearcache (global_State *g) { + int i, j; + for (i = 0; i < STRCACHE_N; i++) + for (j = 0; j < STRCACHE_M; j++) { + if (iswhite(g->strcache[i][j])) /* will entry be collected? */ + g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */ + } +} + + +/* +** Initialize the string table and the string cache +*/ +void luaS_init (lua_State *L) { + global_State *g = G(L); + int i, j; + luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ + /* pre-create memory-error message */ + g->memerrmsg = luaS_newliteral(L, MEMERRMSG); + luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ + for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */ + for (j = 0; j < STRCACHE_M; j++) + g->strcache[i][j] = g->memerrmsg; +} + + + /* ** creates a new string object */ -static TString *createstrobj (lua_State *L, const char *str, size_t l, - int tag, unsigned int h, GCObject **list) { +static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) { TString *ts; + GCObject *o; size_t totalsize; /* total size of TString object */ - totalsize = sizeof(TString) + ((l + 1) * sizeof(char)); - ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts; - ts->tsv.len = l; - ts->tsv.hash = h; - ts->tsv.extra = 0; - memcpy(ts+1, str, l*sizeof(char)); - ((char *)(ts+1))[l] = '\0'; /* ending 0 */ + totalsize = sizelstring(l); + o = luaC_newobj(L, tag, totalsize); + ts = gco2ts(o); + ts->hash = h; + ts->extra = 0; + getstr(ts)[l] = '\0'; /* ending 0 */ return ts; } -/* -** creates a new short string, inserting it into string table -*/ -static TString *newshrstr (lua_State *L, const char *str, size_t l, - unsigned int h) { - GCObject **list; /* (pointer to) list where it will be inserted */ +TString *luaS_createlngstrobj (lua_State *L, size_t l) { + TString *ts = createstrobj(L, l, LUA_TLNGSTR, G(L)->seed); + ts->u.lnglen = l; + return ts; +} + + +void luaS_remove (lua_State *L, TString *ts) { stringtable *tb = &G(L)->strt; - TString *s; - if (tb->nuse >= cast(lu_int32, tb->size) && tb->size <= MAX_INT/2) - luaS_resize(L, tb->size*2); /* too crowded */ - list = &tb->hash[lmod(h, tb->size)]; - s = createstrobj(L, str, l, LUA_TSHRSTR, h, list); - tb->nuse++; - return s; + TString **p = &tb->hash[lmod(ts->hash, tb->size)]; + while (*p != ts) /* find previous element */ + p = &(*p)->u.hnext; + *p = (*p)->u.hnext; /* remove element from its list */ + tb->nuse--; } @@ -131,22 +165,31 @@ static TString *newshrstr (lua_State *L, const char *str, size_t l, ** checks whether short string exists and reuses it or creates a new one */ static TString *internshrstr (lua_State *L, const char *str, size_t l) { - GCObject *o; + TString *ts; global_State *g = G(L); unsigned int h = luaS_hash(str, l, g->seed); - for (o = g->strt.hash[lmod(h, g->strt.size)]; - o != NULL; - o = gch(o)->next) { - TString *ts = rawgco2ts(o); - if (h == ts->tsv.hash && - l == ts->tsv.len && + TString **list = &g->strt.hash[lmod(h, g->strt.size)]; + lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */ + for (ts = *list; ts != NULL; ts = ts->u.hnext) { + if (l == ts->shrlen && (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) { - if (isdead(G(L), o)) /* string is dead (but was not collected yet)? */ - changewhite(o); /* resurrect it */ + /* found! */ + if (isdead(g, ts)) /* dead (but not collected yet)? */ + changewhite(ts); /* resurrect it */ return ts; } } - return newshrstr(L, str, l, h); /* not found; create a new string */ + if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) { + luaS_resize(L, g->strt.size * 2); + list = &g->strt.hash[lmod(h, g->strt.size)]; /* recompute with new size */ + } + ts = createstrobj(L, l, LUA_TSHRSTR, h); + memcpy(getstr(ts), str, l * sizeof(char)); + ts->shrlen = cast_byte(l); + ts->u.hnext = *list; + *list = ts; + g->strt.nuse++; + return ts; } @@ -157,29 +200,49 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { if (l <= LUAI_MAXSHORTLEN) /* short string? */ return internshrstr(L, str, l); else { - if (l + 1 > (MAX_SIZET - sizeof(TString))/sizeof(char)) + TString *ts; + if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char)) luaM_toobig(L); - return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL); + ts = luaS_createlngstrobj(L, l); + memcpy(getstr(ts), str, l * sizeof(char)); + return ts; } } /* -** new zero-terminated string +** Create or reuse a zero-terminated string, first checking in the +** cache (using the string address as a key). The cache can contain +** only zero-terminated strings, so it is safe to use 'strcmp' to +** check hits. */ TString *luaS_new (lua_State *L, const char *str) { - return luaS_newlstr(L, str, strlen(str)); + unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ + int j; + TString **p = G(L)->strcache[i]; + for (j = 0; j < STRCACHE_M; j++) { + if (strcmp(str, getstr(p[j])) == 0) /* hit? */ + return p[j]; /* that is it */ + } + /* normal route */ + for (j = STRCACHE_M - 1; j > 0; j--) + p[j] = p[j - 1]; /* move out last element */ + /* new element is first in the list */ + p[0] = luaS_newlstr(L, str, strlen(str)); + return p[0]; } -Udata *luaS_newudata (lua_State *L, size_t s, Table *e) { +Udata *luaS_newudata (lua_State *L, size_t s) { Udata *u; - if (s > MAX_SIZET - sizeof(Udata)) + GCObject *o; + if (s > MAX_SIZE - sizeof(Udata)) luaM_toobig(L); - u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s, NULL, 0)->u; - u->uv.len = s; - u->uv.metatable = NULL; - u->uv.env = e; + o = luaC_newobj(L, LUA_TUSERDATA, sizeludata(s)); + u = gco2u(o); + u->len = s; + u->metatable = NULL; + setuservalue(L, u, luaO_nilobject); return u; } diff --git a/depends/lua/src/lstrlib.c b/depends/lua/src/lstrlib.c index 9261fd220d..b4bed7e93d 100644 --- a/depends/lua/src/lstrlib.c +++ b/depends/lua/src/lstrlib.c @@ -1,19 +1,24 @@ /* -** $Id: lstrlib.c,v 1.178.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lstrlib.c,v 1.254.1.1 2017/04/19 17:29:57 roberto Exp $ ** Standard library for string operations and pattern-matching ** See Copyright Notice in lua.h */ +#define lstrlib_c +#define LUA_LIB + +#include "lprefix.h" + #include +#include +#include +#include #include #include #include #include -#define lstrlib_c -#define LUA_LIB - #include "lua.h" #include "lauxlib.h" @@ -22,17 +27,29 @@ /* ** maximum number of captures that a pattern can do during -** pattern-matching. This limit is arbitrary. +** pattern-matching. This limit is arbitrary, but must fit in +** an unsigned char. */ #if !defined(LUA_MAXCAPTURES) #define LUA_MAXCAPTURES 32 #endif -/* macro to `unsign' a character */ +/* macro to 'unsign' a character */ #define uchar(c) ((unsigned char)(c)) +/* +** Some sizes are better limited to fit in 'int', but must also fit in +** 'size_t'. (We assume that 'lua_Integer' cannot be smaller than 'int'.) +*/ +#define MAX_SIZET ((size_t)(~(size_t)0)) + +#define MAXSIZE \ + (sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX)) + + + static int str_len (lua_State *L) { size_t l; @@ -43,22 +60,22 @@ static int str_len (lua_State *L) { /* translate a relative string position: negative means back from end */ -static size_t posrelat (ptrdiff_t pos, size_t len) { - if (pos >= 0) return (size_t)pos; +static lua_Integer posrelat (lua_Integer pos, size_t len) { + if (pos >= 0) return pos; else if (0u - (size_t)pos > len) return 0; - else return len - ((size_t)-pos) + 1; + else return (lua_Integer)len + pos + 1; } static int str_sub (lua_State *L) { size_t l; const char *s = luaL_checklstring(L, 1, &l); - size_t start = posrelat(luaL_checkinteger(L, 2), l); - size_t end = posrelat(luaL_optinteger(L, 3, -1), l); + lua_Integer start = posrelat(luaL_checkinteger(L, 2), l); + lua_Integer end = posrelat(luaL_optinteger(L, 3, -1), l); if (start < 1) start = 1; - if (end > l) end = l; + if (end > (lua_Integer)l) end = l; if (start <= end) - lua_pushlstring(L, s + start - 1, end - start + 1); + lua_pushlstring(L, s + start - 1, (size_t)(end - start) + 1); else lua_pushliteral(L, ""); return 1; } @@ -102,25 +119,23 @@ static int str_upper (lua_State *L) { } -/* reasonable limit to avoid arithmetic overflow */ -#define MAXSIZE ((~(size_t)0) >> 1) - static int str_rep (lua_State *L) { size_t l, lsep; const char *s = luaL_checklstring(L, 1, &l); - int n = luaL_checkint(L, 2); + lua_Integer n = luaL_checkinteger(L, 2); const char *sep = luaL_optlstring(L, 3, "", &lsep); if (n <= 0) lua_pushliteral(L, ""); - else if (l + lsep < l || l + lsep >= MAXSIZE / n) /* may overflow? */ + else if (l + lsep < l || l + lsep > MAXSIZE / n) /* may overflow? */ return luaL_error(L, "resulting string too large"); else { - size_t totallen = n * l + (n - 1) * lsep; + size_t totallen = (size_t)n * l + (size_t)(n - 1) * lsep; luaL_Buffer b; char *p = luaL_buffinitsize(L, &b, totallen); while (n-- > 1) { /* first n-1 copies (followed by separator) */ memcpy(p, s, l * sizeof(char)); p += l; - if (lsep > 0) { /* avoid empty 'memcpy' (may be expensive) */ - memcpy(p, sep, lsep * sizeof(char)); p += lsep; + if (lsep > 0) { /* empty 'memcpy' is not that cheap */ + memcpy(p, sep, lsep * sizeof(char)); + p += lsep; } } memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */ @@ -133,15 +148,15 @@ static int str_rep (lua_State *L) { static int str_byte (lua_State *L) { size_t l; const char *s = luaL_checklstring(L, 1, &l); - size_t posi = posrelat(luaL_optinteger(L, 2, 1), l); - size_t pose = posrelat(luaL_optinteger(L, 3, posi), l); + lua_Integer posi = posrelat(luaL_optinteger(L, 2, 1), l); + lua_Integer pose = posrelat(luaL_optinteger(L, 3, posi), l); int n, i; if (posi < 1) posi = 1; - if (pose > l) pose = l; + if (pose > (lua_Integer)l) pose = l; if (posi > pose) return 0; /* empty interval; return no values */ - n = (int)(pose - posi + 1); - if (posi + n <= pose) /* (size_t -> int) overflow? */ + if (pose - posi >= INT_MAX) /* arithmetic overflow? */ return luaL_error(L, "string slice too long"); + n = (int)(pose - posi) + 1; luaL_checkstack(L, n, "string slice too long"); for (i=0; ip_end) - luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")"); + luaL_error(ms->L, "malformed pattern (ends with '%%')"); return p+1; } case '[': { if (*p == '^') p++; - do { /* look for a `]' */ + do { /* look for a ']' */ if (p == ms->p_end) - luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")"); + luaL_error(ms->L, "malformed pattern (missing ']')"); if (*(p++) == L_ESC && p < ms->p_end) - p++; /* skip escapes (e.g. `%]') */ + p++; /* skip escapes (e.g. '%]') */ } while (*p != ']'); return p+1; } @@ -287,7 +303,7 @@ static int matchbracketclass (int c, const char *p, const char *ec) { int sig = 1; if (*(p+1) == '^') { sig = 0; - p++; /* skip the `^' */ + p++; /* skip the '^' */ } while (++p < ec) { if (*p == L_ESC) { @@ -325,8 +341,7 @@ static int singlematch (MatchState *ms, const char *s, const char *p, static const char *matchbalance (MatchState *ms, const char *s, const char *p) { if (p >= ms->p_end - 1) - luaL_error(ms->L, "malformed pattern " - "(missing arguments to " LUA_QL("%%b") ")"); + luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')"); if (*s != *p) return NULL; else { int b = *p; @@ -425,7 +440,7 @@ static const char *match (MatchState *ms, const char *s, const char *p) { break; } case '$': { - if ((p + 1) != ms->p_end) /* is the `$' the last char in pattern? */ + if ((p + 1) != ms->p_end) /* is the '$' the last char in pattern? */ goto dflt; /* no; go to default */ s = (s == ms->src_end) ? s : NULL; /* check end of string */ break; @@ -443,8 +458,7 @@ static const char *match (MatchState *ms, const char *s, const char *p) { const char *ep; char previous; p += 2; if (*p != '[') - luaL_error(ms->L, "missing " LUA_QL("[") " after " - LUA_QL("%%f") " in pattern"); + luaL_error(ms->L, "missing '[' after '%%f' in pattern"); ep = classend(ms, p); /* points to what is next */ previous = (s == ms->src_init) ? '\0' : *(s - 1); if (!matchbracketclass(uchar(previous), p, ep - 1) && @@ -490,7 +504,7 @@ static const char *match (MatchState *ms, const char *s, const char *p) { } case '+': /* 1 or more repetitions */ s++; /* 1 match already done */ - /* go through */ + /* FALLTHROUGH */ case '*': /* 0 or more repetitions */ s = max_expand(ms, s, p, ep); break; @@ -514,16 +528,16 @@ static const char *match (MatchState *ms, const char *s, const char *p) { static const char *lmemfind (const char *s1, size_t l1, const char *s2, size_t l2) { if (l2 == 0) return s1; /* empty strings are everywhere */ - else if (l2 > l1) return NULL; /* avoids a negative `l1' */ + else if (l2 > l1) return NULL; /* avoids a negative 'l1' */ else { - const char *init; /* to search for a `*s2' inside `s1' */ - l2--; /* 1st char will be checked by `memchr' */ - l1 = l1-l2; /* `s2' cannot be found after that */ + const char *init; /* to search for a '*s2' inside 's1' */ + l2--; /* 1st char will be checked by 'memchr' */ + l1 = l1-l2; /* 's2' cannot be found after that */ while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) { init++; /* 1st char is already checked */ if (memcmp(init, s2+1, l2) == 0) return init-1; - else { /* correct `l1' and `s1' to try again */ + else { /* correct 'l1' and 's1' to try again */ l1 -= init-s1; s1 = init; } @@ -539,13 +553,13 @@ static void push_onecapture (MatchState *ms, int i, const char *s, if (i == 0) /* ms->level == 0, too */ lua_pushlstring(ms->L, s, e - s); /* add whole match */ else - luaL_error(ms->L, "invalid capture index"); + luaL_error(ms->L, "invalid capture index %%%d", i + 1); } else { ptrdiff_t l = ms->capture[i].len; if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture"); if (l == CAP_POSITION) - lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1); + lua_pushinteger(ms->L, (ms->capture[i].init - ms->src_init) + 1); else lua_pushlstring(ms->L, ms->capture[i].init, l); } @@ -574,23 +588,39 @@ static int nospecials (const char *p, size_t l) { } +static void prepstate (MatchState *ms, lua_State *L, + const char *s, size_t ls, const char *p, size_t lp) { + ms->L = L; + ms->matchdepth = MAXCCALLS; + ms->src_init = s; + ms->src_end = s + ls; + ms->p_end = p + lp; +} + + +static void reprepstate (MatchState *ms) { + ms->level = 0; + lua_assert(ms->matchdepth == MAXCCALLS); +} + + static int str_find_aux (lua_State *L, int find) { size_t ls, lp; const char *s = luaL_checklstring(L, 1, &ls); const char *p = luaL_checklstring(L, 2, &lp); - size_t init = posrelat(luaL_optinteger(L, 3, 1), ls); + lua_Integer init = posrelat(luaL_optinteger(L, 3, 1), ls); if (init < 1) init = 1; - else if (init > ls + 1) { /* start after string's end? */ + else if (init > (lua_Integer)ls + 1) { /* start after string's end? */ lua_pushnil(L); /* cannot find anything */ return 1; } /* explicit request or no special characters? */ if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) { /* do a plain search */ - const char *s2 = lmemfind(s + init - 1, ls - init + 1, p, lp); + const char *s2 = lmemfind(s + init - 1, ls - (size_t)init + 1, p, lp); if (s2) { - lua_pushinteger(L, s2 - s + 1); - lua_pushinteger(L, s2 - s + lp); + lua_pushinteger(L, (s2 - s) + 1); + lua_pushinteger(L, (s2 - s) + lp); return 2; } } @@ -601,18 +631,13 @@ static int str_find_aux (lua_State *L, int find) { if (anchor) { p++; lp--; /* skip anchor character */ } - ms.L = L; - ms.matchdepth = MAXCCALLS; - ms.src_init = s; - ms.src_end = s + ls; - ms.p_end = p + lp; + prepstate(&ms, L, s, ls, p, lp); do { const char *res; - ms.level = 0; - lua_assert(ms.matchdepth == MAXCCALLS); + reprepstate(&ms); if ((res=match(&ms, s1, p)) != NULL) { if (find) { - lua_pushinteger(L, s1 - s + 1); /* start */ + lua_pushinteger(L, (s1 - s) + 1); /* start */ lua_pushinteger(L, res - s); /* end */ return push_captures(&ms, NULL, 0) + 2; } @@ -636,29 +661,25 @@ static int str_match (lua_State *L) { } +/* state for 'gmatch' */ +typedef struct GMatchState { + const char *src; /* current position */ + const char *p; /* pattern */ + const char *lastmatch; /* end of last match */ + MatchState ms; /* match state */ +} GMatchState; + + static int gmatch_aux (lua_State *L) { - MatchState ms; - size_t ls, lp; - const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls); - const char *p = lua_tolstring(L, lua_upvalueindex(2), &lp); + GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3)); const char *src; - ms.L = L; - ms.matchdepth = MAXCCALLS; - ms.src_init = s; - ms.src_end = s+ls; - ms.p_end = p + lp; - for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3)); - src <= ms.src_end; - src++) { + gm->ms.L = L; + for (src = gm->src; src <= gm->ms.src_end; src++) { const char *e; - ms.level = 0; - lua_assert(ms.matchdepth == MAXCCALLS); - if ((e = match(&ms, src, p)) != NULL) { - lua_Integer newstart = e-s; - if (e == src) newstart++; /* empty match? go at least one position */ - lua_pushinteger(L, newstart); - lua_replace(L, lua_upvalueindex(3)); - return push_captures(&ms, src, e); + reprepstate(&gm->ms); + if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) { + gm->src = gm->lastmatch = e; + return push_captures(&gm->ms, src, e); } } return 0; /* not found */ @@ -666,10 +687,14 @@ static int gmatch_aux (lua_State *L) { static int gmatch (lua_State *L) { - luaL_checkstring(L, 1); - luaL_checkstring(L, 2); - lua_settop(L, 2); - lua_pushinteger(L, 0); + size_t ls, lp; + const char *s = luaL_checklstring(L, 1, &ls); + const char *p = luaL_checklstring(L, 2, &lp); + GMatchState *gm; + lua_settop(L, 2); /* keep them on closure to avoid being collected */ + gm = (GMatchState *)lua_newuserdata(L, sizeof(GMatchState)); + prepstate(&gm->ms, L, s, ls, p, lp); + gm->src = s; gm->p = p; gm->lastmatch = NULL; lua_pushcclosure(L, gmatch_aux, 3); return 1; } @@ -678,7 +703,8 @@ static int gmatch (lua_State *L) { static void add_s (MatchState *ms, luaL_Buffer *b, const char *s, const char *e) { size_t l, i; - const char *news = lua_tolstring(ms->L, 3, &l); + lua_State *L = ms->L; + const char *news = lua_tolstring(L, 3, &l); for (i = 0; i < l; i++) { if (news[i] != L_ESC) luaL_addchar(b, news[i]); @@ -686,14 +712,15 @@ static void add_s (MatchState *ms, luaL_Buffer *b, const char *s, i++; /* skip ESC */ if (!isdigit(uchar(news[i]))) { if (news[i] != L_ESC) - luaL_error(ms->L, "invalid use of " LUA_QL("%c") - " in replacement string", L_ESC); + luaL_error(L, "invalid use of '%c' in replacement string", L_ESC); luaL_addchar(b, news[i]); } else if (news[i] == '0') luaL_addlstring(b, s, e - s); else { push_onecapture(ms, news[i] - '1', s, e); + luaL_tolstring(L, -1, NULL); /* if number, convert it to string */ + lua_remove(L, -2); /* remove original value */ luaL_addvalue(b); /* add capture to accumulated result */ } } @@ -734,12 +761,13 @@ static void add_value (MatchState *ms, luaL_Buffer *b, const char *s, static int str_gsub (lua_State *L) { size_t srcl, lp; - const char *src = luaL_checklstring(L, 1, &srcl); - const char *p = luaL_checklstring(L, 2, &lp); - int tr = lua_type(L, 3); - size_t max_s = luaL_optinteger(L, 4, srcl+1); + const char *src = luaL_checklstring(L, 1, &srcl); /* subject */ + const char *p = luaL_checklstring(L, 2, &lp); /* pattern */ + const char *lastmatch = NULL; /* end of last match */ + int tr = lua_type(L, 3); /* replacement type */ + lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1); /* max replacements */ int anchor = (*p == '^'); - size_t n = 0; + lua_Integer n = 0; /* replacement count */ MatchState ms; luaL_Buffer b; luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING || @@ -749,25 +777,18 @@ static int str_gsub (lua_State *L) { if (anchor) { p++; lp--; /* skip anchor character */ } - ms.L = L; - ms.matchdepth = MAXCCALLS; - ms.src_init = src; - ms.src_end = src+srcl; - ms.p_end = p + lp; + prepstate(&ms, L, src, srcl, p, lp); while (n < max_s) { const char *e; - ms.level = 0; - lua_assert(ms.matchdepth == MAXCCALLS); - e = match(&ms, src, p); - if (e) { + reprepstate(&ms); /* (re)prepare state for new match */ + if ((e = match(&ms, src, p)) != NULL && e != lastmatch) { /* match? */ n++; - add_value(&ms, &b, src, e, tr); + add_value(&ms, &b, src, e, tr); /* add replacement to buffer */ + src = lastmatch = e; } - if (e && e>src) /* non empty match? */ - src = e; /* skip it */ - else if (src < ms.src_end) + else if (src < ms.src_end) /* otherwise, skip one character */ luaL_addchar(&b, *src++); - else break; + else break; /* end of subject */ if (anchor) break; } luaL_addlstring(&b, src, ms.src_end-src); @@ -786,65 +807,117 @@ static int str_gsub (lua_State *L) { ** ======================================================= */ +#if !defined(lua_number2strx) /* { */ + /* -** LUA_INTFRMLEN is the length modifier for integer conversions in -** 'string.format'; LUA_INTFRM_T is the integer type corresponding to -** the previous length +** Hexadecimal floating-point formatter */ -#if !defined(LUA_INTFRMLEN) /* { */ -#if defined(LUA_USE_LONGLONG) -#define LUA_INTFRMLEN "ll" -#define LUA_INTFRM_T long long +#include -#else +#define SIZELENMOD (sizeof(LUA_NUMBER_FRMLEN)/sizeof(char)) -#define LUA_INTFRMLEN "l" -#define LUA_INTFRM_T long -#endif -#endif /* } */ +/* +** Number of bits that goes into the first digit. It can be any value +** between 1 and 4; the following definition tries to align the number +** to nibble boundaries by making what is left after that first digit a +** multiple of 4. +*/ +#define L_NBFD ((l_mathlim(MANT_DIG) - 1)%4 + 1) /* -** LUA_FLTFRMLEN is the length modifier for float conversions in -** 'string.format'; LUA_FLTFRM_T is the float type corresponding to -** the previous length +** Add integer part of 'x' to buffer and return new 'x' */ -#if !defined(LUA_FLTFRMLEN) +static lua_Number adddigit (char *buff, int n, lua_Number x) { + lua_Number dd = l_mathop(floor)(x); /* get integer part from 'x' */ + int d = (int)dd; + buff[n] = (d < 10 ? d + '0' : d - 10 + 'a'); /* add to buffer */ + return x - dd; /* return what is left */ +} -#define LUA_FLTFRMLEN "" -#define LUA_FLTFRM_T double -#endif +static int num2straux (char *buff, int sz, lua_Number x) { + /* if 'inf' or 'NaN', format it like '%g' */ + if (x != x || x == (lua_Number)HUGE_VAL || x == -(lua_Number)HUGE_VAL) + return l_sprintf(buff, sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)x); + else if (x == 0) { /* can be -0... */ + /* create "0" or "-0" followed by exponent */ + return l_sprintf(buff, sz, LUA_NUMBER_FMT "x0p+0", (LUAI_UACNUMBER)x); + } + else { + int e; + lua_Number m = l_mathop(frexp)(x, &e); /* 'x' fraction and exponent */ + int n = 0; /* character count */ + if (m < 0) { /* is number negative? */ + buff[n++] = '-'; /* add signal */ + m = -m; /* make it positive */ + } + buff[n++] = '0'; buff[n++] = 'x'; /* add "0x" */ + m = adddigit(buff, n++, m * (1 << L_NBFD)); /* add first digit */ + e -= L_NBFD; /* this digit goes before the radix point */ + if (m > 0) { /* more digits? */ + buff[n++] = lua_getlocaledecpoint(); /* add radix point */ + do { /* add as many digits as needed */ + m = adddigit(buff, n++, m * 16); + } while (m > 0); + } + n += l_sprintf(buff + n, sz - n, "p%+d", e); /* add exponent */ + lua_assert(n < sz); + return n; + } +} + + +static int lua_number2strx (lua_State *L, char *buff, int sz, + const char *fmt, lua_Number x) { + int n = num2straux(buff, sz, x); + if (fmt[SIZELENMOD] == 'A') { + int i; + for (i = 0; i < n; i++) + buff[i] = toupper(uchar(buff[i])); + } + else if (fmt[SIZELENMOD] != 'a') + return luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented"); + return n; +} + +#endif /* } */ + + +/* +** Maximum size of each formatted item. This maximum size is produced +** by format('%.99f', -maxfloat), and is equal to 99 + 3 ('-', '.', +** and '\0') + number of decimal digits to represent maxfloat (which +** is maximum exponent + 1). (99+3+1 then rounded to 120 for "extra +** expenses", such as locale-dependent stuff) +*/ +#define MAX_ITEM (120 + l_mathlim(MAX_10_EXP)) -/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */ -#define MAX_ITEM 512 /* valid flags in a format specification */ #define FLAGS "-+ #0" + /* -** maximum size of each format specification (such as '%-099.99d') -** (+10 accounts for %99.99x plus margin of error) +** maximum size of each format specification (such as "%-099.99d") */ -#define MAX_FORMAT (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10) +#define MAX_FORMAT 32 -static void addquoted (lua_State *L, luaL_Buffer *b, int arg) { - size_t l; - const char *s = luaL_checklstring(L, arg, &l); +static void addquoted (luaL_Buffer *b, const char *s, size_t len) { luaL_addchar(b, '"'); - while (l--) { + while (len--) { if (*s == '"' || *s == '\\' || *s == '\n') { luaL_addchar(b, '\\'); luaL_addchar(b, *s); } - else if (*s == '\0' || iscntrl(uchar(*s))) { + else if (iscntrl(uchar(*s))) { char buff[10]; if (!isdigit(uchar(*(s+1)))) - sprintf(buff, "\\%d", (int)uchar(*s)); + l_sprintf(buff, sizeof(buff), "\\%d", (int)uchar(*s)); else - sprintf(buff, "\\%03d", (int)uchar(*s)); + l_sprintf(buff, sizeof(buff), "\\%03d", (int)uchar(*s)); luaL_addstring(b, buff); } else @@ -854,6 +927,57 @@ static void addquoted (lua_State *L, luaL_Buffer *b, int arg) { luaL_addchar(b, '"'); } + +/* +** Ensures the 'buff' string uses a dot as the radix character. +*/ +static void checkdp (char *buff, int nb) { + if (memchr(buff, '.', nb) == NULL) { /* no dot? */ + char point = lua_getlocaledecpoint(); /* try locale point */ + char *ppoint = (char *)memchr(buff, point, nb); + if (ppoint) *ppoint = '.'; /* change it to a dot */ + } +} + + +static void addliteral (lua_State *L, luaL_Buffer *b, int arg) { + switch (lua_type(L, arg)) { + case LUA_TSTRING: { + size_t len; + const char *s = lua_tolstring(L, arg, &len); + addquoted(b, s, len); + break; + } + case LUA_TNUMBER: { + char *buff = luaL_prepbuffsize(b, MAX_ITEM); + int nb; + if (!lua_isinteger(L, arg)) { /* float? */ + lua_Number n = lua_tonumber(L, arg); /* write as hexa ('%a') */ + nb = lua_number2strx(L, buff, MAX_ITEM, "%" LUA_NUMBER_FRMLEN "a", n); + checkdp(buff, nb); /* ensure it uses a dot */ + } + else { /* integers */ + lua_Integer n = lua_tointeger(L, arg); + const char *format = (n == LUA_MININTEGER) /* corner case? */ + ? "0x%" LUA_INTEGER_FRMLEN "x" /* use hexa */ + : LUA_INTEGER_FMT; /* else use default format */ + nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n); + } + luaL_addsize(b, nb); + break; + } + case LUA_TNIL: case LUA_TBOOLEAN: { + luaL_tolstring(L, arg, NULL); + luaL_addvalue(b); + break; + } + default: { + luaL_argerror(L, arg, "value has no literal form"); + } + } +} + + static const char *scanformat (lua_State *L, const char *strfrmt, char *form) { const char *p = strfrmt; while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++; /* skip flags */ @@ -869,8 +993,8 @@ static const char *scanformat (lua_State *L, const char *strfrmt, char *form) { if (isdigit(uchar(*p))) luaL_error(L, "invalid format (width or precision too long)"); *(form++) = '%'; - memcpy(form, strfrmt, (p - strfrmt + 1) * sizeof(char)); - form += p - strfrmt + 1; + memcpy(form, strfrmt, ((p - strfrmt) + 1) * sizeof(char)); + form += (p - strfrmt) + 1; *form = '\0'; return p; } @@ -903,7 +1027,7 @@ static int str_format (lua_State *L) { else if (*++strfrmt == L_ESC) luaL_addchar(&b, *strfrmt++); /* %% */ else { /* format item */ - char form[MAX_FORMAT]; /* to store the format (`%...') */ + char form[MAX_FORMAT]; /* to store the format ('%...') */ char *buff = luaL_prepbuffsize(&b, MAX_ITEM); /* to put formatted item */ int nb = 0; /* number of bytes in added item */ if (++arg > top) @@ -911,62 +1035,56 @@ static int str_format (lua_State *L) { strfrmt = scanformat(L, strfrmt, form); switch (*strfrmt++) { case 'c': { - nb = sprintf(buff, form, luaL_checkint(L, arg)); - break; - } - case 'd': case 'i': { - lua_Number n = luaL_checknumber(L, arg); - LUA_INTFRM_T ni = (LUA_INTFRM_T)n; - lua_Number diff = n - (lua_Number)ni; - luaL_argcheck(L, -1 < diff && diff < 1, arg, - "not a number in proper range"); - addlenmod(form, LUA_INTFRMLEN); - nb = sprintf(buff, form, ni); + nb = l_sprintf(buff, MAX_ITEM, form, (int)luaL_checkinteger(L, arg)); break; } + case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': { - lua_Number n = luaL_checknumber(L, arg); - unsigned LUA_INTFRM_T ni = (unsigned LUA_INTFRM_T)n; - lua_Number diff = n - (lua_Number)ni; - luaL_argcheck(L, -1 < diff && diff < 1, arg, - "not a non-negative number in proper range"); - addlenmod(form, LUA_INTFRMLEN); - nb = sprintf(buff, form, ni); + lua_Integer n = luaL_checkinteger(L, arg); + addlenmod(form, LUA_INTEGER_FRMLEN); + nb = l_sprintf(buff, MAX_ITEM, form, (LUAI_UACINT)n); break; } - case 'e': case 'E': case 'f': -#if defined(LUA_USE_AFORMAT) case 'a': case 'A': -#endif + addlenmod(form, LUA_NUMBER_FRMLEN); + nb = lua_number2strx(L, buff, MAX_ITEM, form, + luaL_checknumber(L, arg)); + break; + case 'e': case 'E': case 'f': case 'g': case 'G': { - addlenmod(form, LUA_FLTFRMLEN); - nb = sprintf(buff, form, (LUA_FLTFRM_T)luaL_checknumber(L, arg)); + lua_Number n = luaL_checknumber(L, arg); + addlenmod(form, LUA_NUMBER_FRMLEN); + nb = l_sprintf(buff, MAX_ITEM, form, (LUAI_UACNUMBER)n); break; } case 'q': { - addquoted(L, &b, arg); + addliteral(L, &b, arg); break; } case 's': { size_t l; const char *s = luaL_tolstring(L, arg, &l); - if (!strchr(form, '.') && l >= 100) { - /* no precision and string is too long to be formatted; - keep original string */ - luaL_addvalue(&b); - break; - } + if (form[2] == '\0') /* no modifiers? */ + luaL_addvalue(&b); /* keep entire string */ else { - nb = sprintf(buff, form, s); - lua_pop(L, 1); /* remove result from 'luaL_tolstring' */ - break; + luaL_argcheck(L, l == strlen(s), arg, "string contains zeros"); + if (!strchr(form, '.') && l >= 100) { + /* no precision and string is too long to be formatted */ + luaL_addvalue(&b); /* keep entire string */ + } + else { /* format the string into 'buff' */ + nb = l_sprintf(buff, MAX_ITEM, form, s); + lua_pop(L, 1); /* remove result from 'luaL_tolstring' */ + } } + break; } - default: { /* also treat cases `pnLlh' */ - return luaL_error(L, "invalid option " LUA_QL("%%%c") " to " - LUA_QL("format"), *(strfrmt - 1)); + default: { /* also treat cases 'pnLlh' */ + return luaL_error(L, "invalid option '%%%c' to 'format'", + *(strfrmt - 1)); } } + lua_assert(nb < MAX_ITEM); luaL_addsize(&b, nb); } } @@ -977,6 +1095,450 @@ static int str_format (lua_State *L) { /* }====================================================== */ +/* +** {====================================================== +** PACK/UNPACK +** ======================================================= +*/ + + +/* value used for padding */ +#if !defined(LUAL_PACKPADBYTE) +#define LUAL_PACKPADBYTE 0x00 +#endif + +/* maximum size for the binary representation of an integer */ +#define MAXINTSIZE 16 + +/* number of bits in a character */ +#define NB CHAR_BIT + +/* mask for one character (NB 1's) */ +#define MC ((1 << NB) - 1) + +/* size of a lua_Integer */ +#define SZINT ((int)sizeof(lua_Integer)) + + +/* dummy union to get native endianness */ +static const union { + int dummy; + char little; /* true iff machine is little endian */ +} nativeendian = {1}; + + +/* dummy structure to get native alignment requirements */ +struct cD { + char c; + union { double d; void *p; lua_Integer i; lua_Number n; } u; +}; + +#define MAXALIGN (offsetof(struct cD, u)) + + +/* +** Union for serializing floats +*/ +typedef union Ftypes { + float f; + double d; + lua_Number n; + char buff[5 * sizeof(lua_Number)]; /* enough for any float type */ +} Ftypes; + + +/* +** information to pack/unpack stuff +*/ +typedef struct Header { + lua_State *L; + int islittle; + int maxalign; +} Header; + + +/* +** options for pack/unpack +*/ +typedef enum KOption { + Kint, /* signed integers */ + Kuint, /* unsigned integers */ + Kfloat, /* floating-point numbers */ + Kchar, /* fixed-length strings */ + Kstring, /* strings with prefixed length */ + Kzstr, /* zero-terminated strings */ + Kpadding, /* padding */ + Kpaddalign, /* padding for alignment */ + Knop /* no-op (configuration or spaces) */ +} KOption; + + +/* +** Read an integer numeral from string 'fmt' or return 'df' if +** there is no numeral +*/ +static int digit (int c) { return '0' <= c && c <= '9'; } + +static int getnum (const char **fmt, int df) { + if (!digit(**fmt)) /* no number? */ + return df; /* return default value */ + else { + int a = 0; + do { + a = a*10 + (*((*fmt)++) - '0'); + } while (digit(**fmt) && a <= ((int)MAXSIZE - 9)/10); + return a; + } +} + + +/* +** Read an integer numeral and raises an error if it is larger +** than the maximum size for integers. +*/ +static int getnumlimit (Header *h, const char **fmt, int df) { + int sz = getnum(fmt, df); + if (sz > MAXINTSIZE || sz <= 0) + return luaL_error(h->L, "integral size (%d) out of limits [1,%d]", + sz, MAXINTSIZE); + return sz; +} + + +/* +** Initialize Header +*/ +static void initheader (lua_State *L, Header *h) { + h->L = L; + h->islittle = nativeendian.little; + h->maxalign = 1; +} + + +/* +** Read and classify next option. 'size' is filled with option's size. +*/ +static KOption getoption (Header *h, const char **fmt, int *size) { + int opt = *((*fmt)++); + *size = 0; /* default */ + switch (opt) { + case 'b': *size = sizeof(char); return Kint; + case 'B': *size = sizeof(char); return Kuint; + case 'h': *size = sizeof(short); return Kint; + case 'H': *size = sizeof(short); return Kuint; + case 'l': *size = sizeof(long); return Kint; + case 'L': *size = sizeof(long); return Kuint; + case 'j': *size = sizeof(lua_Integer); return Kint; + case 'J': *size = sizeof(lua_Integer); return Kuint; + case 'T': *size = sizeof(size_t); return Kuint; + case 'f': *size = sizeof(float); return Kfloat; + case 'd': *size = sizeof(double); return Kfloat; + case 'n': *size = sizeof(lua_Number); return Kfloat; + case 'i': *size = getnumlimit(h, fmt, sizeof(int)); return Kint; + case 'I': *size = getnumlimit(h, fmt, sizeof(int)); return Kuint; + case 's': *size = getnumlimit(h, fmt, sizeof(size_t)); return Kstring; + case 'c': + *size = getnum(fmt, -1); + if (*size == -1) + luaL_error(h->L, "missing size for format option 'c'"); + return Kchar; + case 'z': return Kzstr; + case 'x': *size = 1; return Kpadding; + case 'X': return Kpaddalign; + case ' ': break; + case '<': h->islittle = 1; break; + case '>': h->islittle = 0; break; + case '=': h->islittle = nativeendian.little; break; + case '!': h->maxalign = getnumlimit(h, fmt, MAXALIGN); break; + default: luaL_error(h->L, "invalid format option '%c'", opt); + } + return Knop; +} + + +/* +** Read, classify, and fill other details about the next option. +** 'psize' is filled with option's size, 'notoalign' with its +** alignment requirements. +** Local variable 'size' gets the size to be aligned. (Kpadal option +** always gets its full alignment, other options are limited by +** the maximum alignment ('maxalign'). Kchar option needs no alignment +** despite its size. +*/ +static KOption getdetails (Header *h, size_t totalsize, + const char **fmt, int *psize, int *ntoalign) { + KOption opt = getoption(h, fmt, psize); + int align = *psize; /* usually, alignment follows size */ + if (opt == Kpaddalign) { /* 'X' gets alignment from following option */ + if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0) + luaL_argerror(h->L, 1, "invalid next option for option 'X'"); + } + if (align <= 1 || opt == Kchar) /* need no alignment? */ + *ntoalign = 0; + else { + if (align > h->maxalign) /* enforce maximum alignment */ + align = h->maxalign; + if ((align & (align - 1)) != 0) /* is 'align' not a power of 2? */ + luaL_argerror(h->L, 1, "format asks for alignment not power of 2"); + *ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1); + } + return opt; +} + + +/* +** Pack integer 'n' with 'size' bytes and 'islittle' endianness. +** The final 'if' handles the case when 'size' is larger than +** the size of a Lua integer, correcting the extra sign-extension +** bytes if necessary (by default they would be zeros). +*/ +static void packint (luaL_Buffer *b, lua_Unsigned n, + int islittle, int size, int neg) { + char *buff = luaL_prepbuffsize(b, size); + int i; + buff[islittle ? 0 : size - 1] = (char)(n & MC); /* first byte */ + for (i = 1; i < size; i++) { + n >>= NB; + buff[islittle ? i : size - 1 - i] = (char)(n & MC); + } + if (neg && size > SZINT) { /* negative number need sign extension? */ + for (i = SZINT; i < size; i++) /* correct extra bytes */ + buff[islittle ? i : size - 1 - i] = (char)MC; + } + luaL_addsize(b, size); /* add result to buffer */ +} + + +/* +** Copy 'size' bytes from 'src' to 'dest', correcting endianness if +** given 'islittle' is different from native endianness. +*/ +static void copywithendian (volatile char *dest, volatile const char *src, + int size, int islittle) { + if (islittle == nativeendian.little) { + while (size-- != 0) + *(dest++) = *(src++); + } + else { + dest += size - 1; + while (size-- != 0) + *(dest--) = *(src++); + } +} + + +static int str_pack (lua_State *L) { + luaL_Buffer b; + Header h; + const char *fmt = luaL_checkstring(L, 1); /* format string */ + int arg = 1; /* current argument to pack */ + size_t totalsize = 0; /* accumulate total size of result */ + initheader(L, &h); + lua_pushnil(L); /* mark to separate arguments from string buffer */ + luaL_buffinit(L, &b); + while (*fmt != '\0') { + int size, ntoalign; + KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign); + totalsize += ntoalign + size; + while (ntoalign-- > 0) + luaL_addchar(&b, LUAL_PACKPADBYTE); /* fill alignment */ + arg++; + switch (opt) { + case Kint: { /* signed integers */ + lua_Integer n = luaL_checkinteger(L, arg); + if (size < SZINT) { /* need overflow check? */ + lua_Integer lim = (lua_Integer)1 << ((size * NB) - 1); + luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow"); + } + packint(&b, (lua_Unsigned)n, h.islittle, size, (n < 0)); + break; + } + case Kuint: { /* unsigned integers */ + lua_Integer n = luaL_checkinteger(L, arg); + if (size < SZINT) /* need overflow check? */ + luaL_argcheck(L, (lua_Unsigned)n < ((lua_Unsigned)1 << (size * NB)), + arg, "unsigned overflow"); + packint(&b, (lua_Unsigned)n, h.islittle, size, 0); + break; + } + case Kfloat: { /* floating-point options */ + volatile Ftypes u; + char *buff = luaL_prepbuffsize(&b, size); + lua_Number n = luaL_checknumber(L, arg); /* get argument */ + if (size == sizeof(u.f)) u.f = (float)n; /* copy it into 'u' */ + else if (size == sizeof(u.d)) u.d = (double)n; + else u.n = n; + /* move 'u' to final result, correcting endianness if needed */ + copywithendian(buff, u.buff, size, h.islittle); + luaL_addsize(&b, size); + break; + } + case Kchar: { /* fixed-size string */ + size_t len; + const char *s = luaL_checklstring(L, arg, &len); + luaL_argcheck(L, len <= (size_t)size, arg, + "string longer than given size"); + luaL_addlstring(&b, s, len); /* add string */ + while (len++ < (size_t)size) /* pad extra space */ + luaL_addchar(&b, LUAL_PACKPADBYTE); + break; + } + case Kstring: { /* strings with length count */ + size_t len; + const char *s = luaL_checklstring(L, arg, &len); + luaL_argcheck(L, size >= (int)sizeof(size_t) || + len < ((size_t)1 << (size * NB)), + arg, "string length does not fit in given size"); + packint(&b, (lua_Unsigned)len, h.islittle, size, 0); /* pack length */ + luaL_addlstring(&b, s, len); + totalsize += len; + break; + } + case Kzstr: { /* zero-terminated string */ + size_t len; + const char *s = luaL_checklstring(L, arg, &len); + luaL_argcheck(L, strlen(s) == len, arg, "string contains zeros"); + luaL_addlstring(&b, s, len); + luaL_addchar(&b, '\0'); /* add zero at the end */ + totalsize += len + 1; + break; + } + case Kpadding: luaL_addchar(&b, LUAL_PACKPADBYTE); /* FALLTHROUGH */ + case Kpaddalign: case Knop: + arg--; /* undo increment */ + break; + } + } + luaL_pushresult(&b); + return 1; +} + + +static int str_packsize (lua_State *L) { + Header h; + const char *fmt = luaL_checkstring(L, 1); /* format string */ + size_t totalsize = 0; /* accumulate total size of result */ + initheader(L, &h); + while (*fmt != '\0') { + int size, ntoalign; + KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign); + size += ntoalign; /* total space used by option */ + luaL_argcheck(L, totalsize <= MAXSIZE - size, 1, + "format result too large"); + totalsize += size; + switch (opt) { + case Kstring: /* strings with length count */ + case Kzstr: /* zero-terminated string */ + luaL_argerror(L, 1, "variable-length format"); + /* call never return, but to avoid warnings: *//* FALLTHROUGH */ + default: break; + } + } + lua_pushinteger(L, (lua_Integer)totalsize); + return 1; +} + + +/* +** Unpack an integer with 'size' bytes and 'islittle' endianness. +** If size is smaller than the size of a Lua integer and integer +** is signed, must do sign extension (propagating the sign to the +** higher bits); if size is larger than the size of a Lua integer, +** it must check the unread bytes to see whether they do not cause an +** overflow. +*/ +static lua_Integer unpackint (lua_State *L, const char *str, + int islittle, int size, int issigned) { + lua_Unsigned res = 0; + int i; + int limit = (size <= SZINT) ? size : SZINT; + for (i = limit - 1; i >= 0; i--) { + res <<= NB; + res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i]; + } + if (size < SZINT) { /* real size smaller than lua_Integer? */ + if (issigned) { /* needs sign extension? */ + lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1); + res = ((res ^ mask) - mask); /* do sign extension */ + } + } + else if (size > SZINT) { /* must check unread bytes */ + int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC; + for (i = limit; i < size; i++) { + if ((unsigned char)str[islittle ? i : size - 1 - i] != mask) + luaL_error(L, "%d-byte integer does not fit into Lua Integer", size); + } + } + return (lua_Integer)res; +} + + +static int str_unpack (lua_State *L) { + Header h; + const char *fmt = luaL_checkstring(L, 1); + size_t ld; + const char *data = luaL_checklstring(L, 2, &ld); + size_t pos = (size_t)posrelat(luaL_optinteger(L, 3, 1), ld) - 1; + int n = 0; /* number of results */ + luaL_argcheck(L, pos <= ld, 3, "initial position out of string"); + initheader(L, &h); + while (*fmt != '\0') { + int size, ntoalign; + KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign); + if ((size_t)ntoalign + size > ~pos || pos + ntoalign + size > ld) + luaL_argerror(L, 2, "data string too short"); + pos += ntoalign; /* skip alignment */ + /* stack space for item + next position */ + luaL_checkstack(L, 2, "too many results"); + n++; + switch (opt) { + case Kint: + case Kuint: { + lua_Integer res = unpackint(L, data + pos, h.islittle, size, + (opt == Kint)); + lua_pushinteger(L, res); + break; + } + case Kfloat: { + volatile Ftypes u; + lua_Number num; + copywithendian(u.buff, data + pos, size, h.islittle); + if (size == sizeof(u.f)) num = (lua_Number)u.f; + else if (size == sizeof(u.d)) num = (lua_Number)u.d; + else num = u.n; + lua_pushnumber(L, num); + break; + } + case Kchar: { + lua_pushlstring(L, data + pos, size); + break; + } + case Kstring: { + size_t len = (size_t)unpackint(L, data + pos, h.islittle, size, 0); + luaL_argcheck(L, pos + len + size <= ld, 2, "data string too short"); + lua_pushlstring(L, data + pos + size, len); + pos += len; /* skip string */ + break; + } + case Kzstr: { + size_t len = (int)strlen(data + pos); + lua_pushlstring(L, data + pos, len); + pos += len + 1; /* skip string plus final '\0' */ + break; + } + case Kpaddalign: case Kpadding: case Knop: + n--; /* undo increment */ + break; + } + pos += size; + } + lua_pushinteger(L, pos + 1); /* next position */ + return n + 1; +} + +/* }====================================================== */ + + static const luaL_Reg strlib[] = { {"byte", str_byte}, {"char", str_char}, @@ -992,6 +1554,9 @@ static const luaL_Reg strlib[] = { {"reverse", str_reverse}, {"sub", str_sub}, {"upper", str_upper}, + {"pack", str_pack}, + {"packsize", str_packsize}, + {"unpack", str_unpack}, {NULL, NULL} }; diff --git a/depends/lua/src/ltable.c b/depends/lua/src/ltable.c index 5d76f97ec3..ea4fe7fcb3 100644 --- a/depends/lua/src/ltable.c +++ b/depends/lua/src/ltable.c @@ -1,27 +1,30 @@ /* -** $Id: ltable.c,v 2.72.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: ltable.c,v 2.118.1.4 2018/06/08 16:22:51 roberto Exp $ ** Lua tables (hash) ** See Copyright Notice in lua.h */ +#define ltable_c +#define LUA_CORE + +#include "lprefix.h" + /* ** Implementation of tables (aka arrays, objects, or hash tables). ** Tables keep its elements in two parts: an array part and a hash part. ** Non-negative integer keys are all candidates to be kept in the array -** part. The actual size of the array is the largest `n' such that at -** least half the slots between 0 and n are in use. +** part. The actual size of the array is the largest 'n' such that +** more than half the slots between 1 and n are in use. ** Hash uses a mix of chained scatter table with Brent's variation. ** A main invariant of these tables is that, if an element is not -** in its main position (i.e. the `original' position that its hash gives +** in its main position (i.e. the 'original' position that its hash gives ** to it), then the colliding element is in its own main position. ** Hence even when the load factor reaches 100%, performance remains good. */ -#include - -#define ltable_c -#define LUA_CORE +#include +#include #include "lua.h" @@ -37,21 +40,26 @@ /* -** max size of array part is 2^MAXBITS +** Maximum size of array part (MAXASIZE) is 2^MAXABITS. MAXABITS is +** the largest integer such that MAXASIZE fits in an unsigned int. */ -#if LUAI_BITSINT >= 32 -#define MAXBITS 30 -#else -#define MAXBITS (LUAI_BITSINT-2) -#endif +#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) +#define MAXASIZE (1u << MAXABITS) -#define MAXASIZE (1 << MAXBITS) +/* +** Maximum size of hash part is 2^MAXHBITS. MAXHBITS is the largest +** integer such that 2^MAXHBITS fits in a signed int. (Note that the +** maximum number of elements in a table, 2^MAXABITS + 2^MAXHBITS, still +** fits comfortably in an unsigned int.) +*/ +#define MAXHBITS (MAXABITS - 1) #define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) -#define hashstr(t,str) hashpow2(t, (str)->tsv.hash) +#define hashstr(t,str) hashpow2(t, (str)->hash) #define hashboolean(t,p) hashpow2(t, p) +#define hashint(t,i) hashpow2(t, i) /* @@ -61,53 +69,61 @@ #define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) -#define hashpointer(t,p) hashmod(t, IntPoint(p)) +#define hashpointer(t,p) hashmod(t, point2uint(p)) #define dummynode (&dummynode_) -#define isdummy(n) ((n) == dummynode) - static const Node dummynode_ = { {NILCONSTANT}, /* value */ - {{NILCONSTANT, NULL}} /* key */ + {{NILCONSTANT, 0}} /* key */ }; /* -** hash for lua_Numbers +** Hash for floating-point numbers. +** The main computation should be just +** n = frexp(n, &i); return (n * INT_MAX) + i +** but there are some numerical subtleties. +** In a two-complement representation, INT_MAX does not has an exact +** representation as a float, but INT_MIN does; because the absolute +** value of 'frexp' is smaller than 1 (unless 'n' is inf/NaN), the +** absolute value of the product 'frexp * -INT_MIN' is smaller or equal +** to INT_MAX. Next, the use of 'unsigned int' avoids overflows when +** adding 'i'; the use of '~u' (instead of '-u') avoids problems with +** INT_MIN. */ -static Node *hashnum (const Table *t, lua_Number n) { +#if !defined(l_hashfloat) +static int l_hashfloat (lua_Number n) { int i; - luai_hashnum(i, n); - if (i < 0) { - if (cast(unsigned int, i) == 0u - i) /* use unsigned to avoid overflows */ - i = 0; /* handle INT_MIN */ - i = -i; /* must be a positive value */ + lua_Integer ni; + n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); + if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */ + lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL)); + return 0; + } + else { /* normal case */ + unsigned int u = cast(unsigned int, i) + cast(unsigned int, ni); + return cast_int(u <= cast(unsigned int, INT_MAX) ? u : ~u); } - return hashmod(t, i); } - +#endif /* -** returns the `main' position of an element in a table (that is, the index +** returns the 'main' position of an element in a table (that is, the index ** of its hash value) */ static Node *mainposition (const Table *t, const TValue *key) { switch (ttype(key)) { - case LUA_TNUMBER: - return hashnum(t, nvalue(key)); - case LUA_TLNGSTR: { - TString *s = rawtsvalue(key); - if (s->tsv.extra == 0) { /* no hash? */ - s->tsv.hash = luaS_hash(getstr(s), s->tsv.len, s->tsv.hash); - s->tsv.extra = 1; /* now it has its hash */ - } - return hashstr(t, rawtsvalue(key)); - } + case LUA_TNUMINT: + return hashint(t, ivalue(key)); + case LUA_TNUMFLT: + return hashmod(t, l_hashfloat(fltvalue(key))); case LUA_TSHRSTR: - return hashstr(t, rawtsvalue(key)); + return hashstr(t, tsvalue(key)); + case LUA_TLNGSTR: + return hashpow2(t, luaS_hashlongstr(tsvalue(key))); case LUA_TBOOLEAN: return hashboolean(t, bvalue(key)); case LUA_TLIGHTUSERDATA: @@ -115,67 +131,68 @@ static Node *mainposition (const Table *t, const TValue *key) { case LUA_TLCF: return hashpointer(t, fvalue(key)); default: + lua_assert(!ttisdeadkey(key)); return hashpointer(t, gcvalue(key)); } } /* -** returns the index for `key' if `key' is an appropriate key to live in -** the array part of the table, -1 otherwise. +** returns the index for 'key' if 'key' is an appropriate key to live in +** the array part of the table, 0 otherwise. */ -static int arrayindex (const TValue *key) { - if (ttisnumber(key)) { - lua_Number n = nvalue(key); - int k; - lua_number2int(k, n); - if (luai_numeq(cast_num(k), n)) - return k; +static unsigned int arrayindex (const TValue *key) { + if (ttisinteger(key)) { + lua_Integer k = ivalue(key); + if (0 < k && (lua_Unsigned)k <= MAXASIZE) + return cast(unsigned int, k); /* 'key' is an appropriate array index */ } - return -1; /* `key' did not match some condition */ + return 0; /* 'key' did not match some condition */ } /* -** returns the index of a `key' for table traversals. First goes all +** returns the index of a 'key' for table traversals. First goes all ** elements in the array part, then elements in the hash part. The -** beginning of a traversal is signaled by -1. +** beginning of a traversal is signaled by 0. */ -static int findindex (lua_State *L, Table *t, StkId key) { - int i; - if (ttisnil(key)) return -1; /* first iteration */ +static unsigned int findindex (lua_State *L, Table *t, StkId key) { + unsigned int i; + if (ttisnil(key)) return 0; /* first iteration */ i = arrayindex(key); - if (0 < i && i <= t->sizearray) /* is `key' inside array part? */ - return i-1; /* yes; that's the index (corrected to C) */ + if (i != 0 && i <= t->sizearray) /* is 'key' inside array part? */ + return i; /* yes; that's the index */ else { + int nx; Node *n = mainposition(t, key); - for (;;) { /* check whether `key' is somewhere in the chain */ - /* key may be dead already, but it is ok to use it in `next' */ + for (;;) { /* check whether 'key' is somewhere in the chain */ + /* key may be dead already, but it is ok to use it in 'next' */ if (luaV_rawequalobj(gkey(n), key) || (ttisdeadkey(gkey(n)) && iscollectable(key) && deadvalue(gkey(n)) == gcvalue(key))) { i = cast_int(n - gnode(t, 0)); /* key index in hash table */ /* hash elements are numbered after array ones */ - return i + t->sizearray; + return (i + 1) + t->sizearray; } - else n = gnext(n); - if (n == NULL) - luaG_runerror(L, "invalid key to " LUA_QL("next")); /* key not found */ + nx = gnext(n); + if (nx == 0) + luaG_runerror(L, "invalid key to 'next'"); /* key not found */ + else n += nx; } } } int luaH_next (lua_State *L, Table *t, StkId key) { - int i = findindex(L, t, key); /* find original element */ - for (i++; i < t->sizearray; i++) { /* try first array part */ + unsigned int i = findindex(L, t, key); /* find original element */ + for (; i < t->sizearray; i++) { /* try first array part */ if (!ttisnil(&t->array[i])) { /* a non-nil value? */ - setnvalue(key, cast_num(i+1)); + setivalue(key, i + 1); setobj2s(L, key+1, &t->array[i]); return 1; } } - for (i -= t->sizearray; i < sizenode(t); i++) { /* then hash part */ + for (i -= t->sizearray; cast_int(i) < sizenode(t); i++) { /* hash part */ if (!ttisnil(gval(gnode(t, i)))) { /* a non-nil value? */ setobj2s(L, key, gkey(gnode(t, i))); setobj2s(L, key+1, gval(gnode(t, i))); @@ -192,32 +209,40 @@ int luaH_next (lua_State *L, Table *t, StkId key) { ** ============================================================== */ - -static int computesizes (int nums[], int *narray) { +/* +** Compute the optimal size for the array part of table 't'. 'nums' is a +** "count array" where 'nums[i]' is the number of integers in the table +** between 2^(i - 1) + 1 and 2^i. 'pna' enters with the total number of +** integer keys in the table and leaves with the number of keys that +** will go to the array part; return the optimal size. +*/ +static unsigned int computesizes (unsigned int nums[], unsigned int *pna) { int i; - int twotoi; /* 2^i */ - int a = 0; /* number of elements smaller than 2^i */ - int na = 0; /* number of elements to go to array part */ - int n = 0; /* optimal size for array part */ - for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) { + unsigned int twotoi; /* 2^i (candidate for optimal size) */ + unsigned int a = 0; /* number of elements smaller than 2^i */ + unsigned int na = 0; /* number of elements to go to array part */ + unsigned int optimal = 0; /* optimal size for array part */ + /* loop while keys can fill more than half of total size */ + for (i = 0, twotoi = 1; + twotoi > 0 && *pna > twotoi / 2; + i++, twotoi *= 2) { if (nums[i] > 0) { a += nums[i]; if (a > twotoi/2) { /* more than half elements present? */ - n = twotoi; /* optimal size (till now) */ - na = a; /* all elements smaller than n will go to array part */ + optimal = twotoi; /* optimal size (till now) */ + na = a; /* all elements up to 'optimal' will go to array part */ } } - if (a == *narray) break; /* all elements already counted */ } - *narray = n; - lua_assert(*narray/2 <= na && na <= *narray); - return na; + lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal); + *pna = na; + return optimal; } -static int countint (const TValue *key, int *nums) { - int k = arrayindex(key); - if (0 < k && k <= MAXASIZE) { /* is `key' an appropriate array index? */ +static int countint (const TValue *key, unsigned int *nums) { + unsigned int k = arrayindex(key); + if (k != 0) { /* is 'key' an appropriate array index? */ nums[luaO_ceillog2(k)]++; /* count as such */ return 1; } @@ -226,20 +251,26 @@ static int countint (const TValue *key, int *nums) { } -static int numusearray (const Table *t, int *nums) { +/* +** Count keys in array part of table 't': Fill 'nums[i]' with +** number of keys that will go into corresponding slice and return +** total number of non-nil keys. +*/ +static unsigned int numusearray (const Table *t, unsigned int *nums) { int lg; - int ttlg; /* 2^lg */ - int ause = 0; /* summation of `nums' */ - int i = 1; /* count to traverse all array keys */ - for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) { /* for each slice */ - int lc = 0; /* counter */ - int lim = ttlg; + unsigned int ttlg; /* 2^lg */ + unsigned int ause = 0; /* summation of 'nums' */ + unsigned int i = 1; /* count to traverse all array keys */ + /* traverse each slice */ + for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) { + unsigned int lc = 0; /* counter */ + unsigned int lim = ttlg; if (lim > t->sizearray) { lim = t->sizearray; /* adjust upper limit */ if (i > lim) break; /* no more elements to count */ } - /* count elements in range (2^(lg-1), 2^lg] */ + /* count elements in range (2^(lg - 1), 2^lg] */ for (; i <= lim; i++) { if (!ttisnil(&t->array[i-1])) lc++; @@ -251,9 +282,9 @@ static int numusearray (const Table *t, int *nums) { } -static int numusehash (const Table *t, int *nums, int *pnasize) { +static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) { int totaluse = 0; /* total number of elements */ - int ause = 0; /* summation of `nums' */ + int ause = 0; /* elements added to 'nums' (can go to array part) */ int i = sizenode(t); while (i--) { Node *n = &t->node[i]; @@ -262,13 +293,13 @@ static int numusehash (const Table *t, int *nums, int *pnasize) { totaluse++; } } - *pnasize += ause; + *pna += ause; return totaluse; } -static void setarrayvector (lua_State *L, Table *t, int size) { - int i; +static void setarrayvector (lua_State *L, Table *t, unsigned int size) { + unsigned int i; luaM_reallocvector(L, t->array, t->sizearray, size, TValue); for (i=t->sizearray; iarray[i]); @@ -276,40 +307,59 @@ static void setarrayvector (lua_State *L, Table *t, int size) { } -static void setnodevector (lua_State *L, Table *t, int size) { - int lsize; +static void setnodevector (lua_State *L, Table *t, unsigned int size) { if (size == 0) { /* no elements to hash part? */ - t->node = cast(Node *, dummynode); /* use common `dummynode' */ - lsize = 0; + t->node = cast(Node *, dummynode); /* use common 'dummynode' */ + t->lsizenode = 0; + t->lastfree = NULL; /* signal that it is using dummy node */ } else { int i; - lsize = luaO_ceillog2(size); - if (lsize > MAXBITS) + int lsize = luaO_ceillog2(size); + if (lsize > MAXHBITS) luaG_runerror(L, "table overflow"); size = twoto(lsize); t->node = luaM_newvector(L, size, Node); - for (i=0; ilsizenode = cast_byte(lsize); + t->lastfree = gnode(t, size); /* all positions are free */ } - t->lsizenode = cast_byte(lsize); - t->lastfree = gnode(t, size); /* all positions are free */ } -void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize) { - int i; - int oldasize = t->sizearray; - int oldhsize = t->lsizenode; +typedef struct { + Table *t; + unsigned int nhsize; +} AuxsetnodeT; + + +static void auxsetnode (lua_State *L, void *ud) { + AuxsetnodeT *asn = cast(AuxsetnodeT *, ud); + setnodevector(L, asn->t, asn->nhsize); +} + + +void luaH_resize (lua_State *L, Table *t, unsigned int nasize, + unsigned int nhsize) { + unsigned int i; + int j; + AuxsetnodeT asn; + unsigned int oldasize = t->sizearray; + int oldhsize = allocsizenode(t); Node *nold = t->node; /* save old hash ... */ if (nasize > oldasize) /* array part must grow? */ setarrayvector(L, t, nasize); /* create new hash part with appropriate size */ - setnodevector(L, t, nhsize); + asn.t = t; asn.nhsize = nhsize; + if (luaD_rawrunprotected(L, auxsetnode, &asn) != LUA_OK) { /* mem. error? */ + setarrayvector(L, t, oldasize); /* array back to its original size */ + luaD_throw(L, LUA_ERRMEM); /* rethrow memory error */ + } if (nasize < oldasize) { /* array part must shrink? */ t->sizearray = nasize; /* re-insert elements from vanishing slice */ @@ -321,41 +371,44 @@ void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize) { luaM_reallocvector(L, t->array, oldasize, nasize, TValue); } /* re-insert elements from hash part */ - for (i = twoto(oldhsize) - 1; i >= 0; i--) { - Node *old = nold+i; + for (j = oldhsize - 1; j >= 0; j--) { + Node *old = nold + j; if (!ttisnil(gval(old))) { /* doesn't need barrier/invalidate cache, as entry was already present in the table */ setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old)); } } - if (!isdummy(nold)) - luaM_freearray(L, nold, cast(size_t, twoto(oldhsize))); /* free old array */ + if (oldhsize > 0) /* not the dummy node? */ + luaM_freearray(L, nold, cast(size_t, oldhsize)); /* free old hash */ } -void luaH_resizearray (lua_State *L, Table *t, int nasize) { - int nsize = isdummy(t->node) ? 0 : sizenode(t); +void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) { + int nsize = allocsizenode(t); luaH_resize(L, t, nasize, nsize); } - +/* +** nums[i] = number of keys 'k' where 2^(i - 1) < k <= 2^i +*/ static void rehash (lua_State *L, Table *t, const TValue *ek) { - int nasize, na; - int nums[MAXBITS+1]; /* nums[i] = number of keys with 2^(i-1) < k <= 2^i */ + unsigned int asize; /* optimal size for array part */ + unsigned int na; /* number of keys in the array part */ + unsigned int nums[MAXABITS + 1]; int i; int totaluse; - for (i=0; i<=MAXBITS; i++) nums[i] = 0; /* reset counts */ - nasize = numusearray(t, nums); /* count keys in array part */ - totaluse = nasize; /* all those keys are integer keys */ - totaluse += numusehash(t, nums, &nasize); /* count keys in hash part */ + for (i = 0; i <= MAXABITS; i++) nums[i] = 0; /* reset counts */ + na = numusearray(t, nums); /* count keys in array part */ + totaluse = na; /* all those keys are integer keys */ + totaluse += numusehash(t, nums, &na); /* count keys in hash part */ /* count extra key */ - nasize += countint(ek, nums); + na += countint(ek, nums); totaluse++; /* compute new size for array part */ - na = computesizes(nums, &nasize); + asize = computesizes(nums, &na); /* resize the table to new computed sizes */ - luaH_resize(L, t, nasize, totaluse - na); + luaH_resize(L, t, asize, totaluse - na); } @@ -366,7 +419,8 @@ static void rehash (lua_State *L, Table *t, const TValue *ek) { Table *luaH_new (lua_State *L) { - Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table), NULL, 0)->h; + GCObject *o = luaC_newobj(L, LUA_TTABLE, sizeof(Table)); + Table *t = gco2t(o); t->metatable = NULL; t->flags = cast_byte(~0); t->array = NULL; @@ -377,7 +431,7 @@ Table *luaH_new (lua_State *L) { void luaH_free (lua_State *L, Table *t) { - if (!isdummy(t->node)) + if (!isdummy(t)) luaM_freearray(L, t->node, cast(size_t, sizenode(t))); luaM_freearray(L, t->array, t->sizearray); luaM_free(L, t); @@ -385,10 +439,12 @@ void luaH_free (lua_State *L, Table *t) { static Node *getfreepos (Table *t) { - while (t->lastfree > t->node) { - t->lastfree--; - if (ttisnil(gkey(t->lastfree))) - return t->lastfree; + if (!isdummy(t)) { + while (t->lastfree > t->node) { + t->lastfree--; + if (ttisnil(gkey(t->lastfree))) + return t->lastfree; + } } return NULL; /* could not find a free place */ } @@ -404,37 +460,51 @@ static Node *getfreepos (Table *t) { */ TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) { Node *mp; + TValue aux; if (ttisnil(key)) luaG_runerror(L, "table index is nil"); - else if (ttisnumber(key) && luai_numisnan(L, nvalue(key))) - luaG_runerror(L, "table index is NaN"); + else if (ttisfloat(key)) { + lua_Integer k; + if (luaV_tointeger(key, &k, 0)) { /* does index fit in an integer? */ + setivalue(&aux, k); + key = &aux; /* insert it as an integer */ + } + else if (luai_numisnan(fltvalue(key))) + luaG_runerror(L, "table index is NaN"); + } mp = mainposition(t, key); - if (!ttisnil(gval(mp)) || isdummy(mp)) { /* main position is taken? */ + if (!ttisnil(gval(mp)) || isdummy(t)) { /* main position is taken? */ Node *othern; - Node *n = getfreepos(t); /* get a free place */ - if (n == NULL) { /* cannot find a free place? */ + Node *f = getfreepos(t); /* get a free place */ + if (f == NULL) { /* cannot find a free place? */ rehash(L, t, key); /* grow table */ - /* whatever called 'newkey' take care of TM cache and GC barrier */ + /* whatever called 'newkey' takes care of TM cache */ return luaH_set(L, t, key); /* insert key into grown table */ } - lua_assert(!isdummy(n)); + lua_assert(!isdummy(t)); othern = mainposition(t, gkey(mp)); if (othern != mp) { /* is colliding node out of its main position? */ /* yes; move colliding node into free position */ - while (gnext(othern) != mp) othern = gnext(othern); /* find previous */ - gnext(othern) = n; /* redo the chain with `n' in place of `mp' */ - *n = *mp; /* copy colliding node into free pos. (mp->next also goes) */ - gnext(mp) = NULL; /* now `mp' is free */ + while (othern + gnext(othern) != mp) /* find previous */ + othern += gnext(othern); + gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ + *f = *mp; /* copy colliding node into free pos. (mp->next also goes) */ + if (gnext(mp) != 0) { + gnext(f) += cast_int(mp - f); /* correct 'next' */ + gnext(mp) = 0; /* now 'mp' is free */ + } setnilvalue(gval(mp)); } else { /* colliding node is in its own main position */ /* new node will go into free position */ - gnext(n) = gnext(mp); /* chain new position */ - gnext(mp) = n; - mp = n; + if (gnext(mp) != 0) + gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ + else lua_assert(gnext(f) == 0); + gnext(mp) = cast_int(f - mp); + mp = f; } } - setobj2t(L, gkey(mp), key); - luaC_barrierback(L, obj2gco(t), key); + setnodekey(L, &mp->i_key, key); + luaC_barrierback(L, t, key); lua_assert(ttisnil(gval(mp))); return gval(mp); } @@ -443,18 +513,21 @@ TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) { /* ** search function for integers */ -const TValue *luaH_getint (Table *t, int key) { +const TValue *luaH_getint (Table *t, lua_Integer key) { /* (1 <= key && key <= t->sizearray) */ - if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray)) - return &t->array[key-1]; + if (l_castS2U(key) - 1 < t->sizearray) + return &t->array[key - 1]; else { - lua_Number nk = cast_num(key); - Node *n = hashnum(t, nk); - do { /* check whether `key' is somewhere in the chain */ - if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk)) + Node *n = hashint(t, key); + for (;;) { /* check whether 'key' is somewhere in the chain */ + if (ttisinteger(gkey(n)) && ivalue(gkey(n)) == key) return gval(n); /* that's it */ - else n = gnext(n); - } while (n); + else { + int nx = gnext(n); + if (nx == 0) break; + n += nx; + } + } return luaO_nilobject; } } @@ -463,15 +536,50 @@ const TValue *luaH_getint (Table *t, int key) { /* ** search function for short strings */ -const TValue *luaH_getstr (Table *t, TString *key) { +const TValue *luaH_getshortstr (Table *t, TString *key) { Node *n = hashstr(t, key); - lua_assert(key->tsv.tt == LUA_TSHRSTR); - do { /* check whether `key' is somewhere in the chain */ - if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key)) + lua_assert(key->tt == LUA_TSHRSTR); + for (;;) { /* check whether 'key' is somewhere in the chain */ + const TValue *k = gkey(n); + if (ttisshrstring(k) && eqshrstr(tsvalue(k), key)) + return gval(n); /* that's it */ + else { + int nx = gnext(n); + if (nx == 0) + return luaO_nilobject; /* not found */ + n += nx; + } + } +} + + +/* +** "Generic" get version. (Not that generic: not valid for integers, +** which may be in array part, nor for floats with integral values.) +*/ +static const TValue *getgeneric (Table *t, const TValue *key) { + Node *n = mainposition(t, key); + for (;;) { /* check whether 'key' is somewhere in the chain */ + if (luaV_rawequalobj(gkey(n), key)) return gval(n); /* that's it */ - else n = gnext(n); - } while (n); - return luaO_nilobject; + else { + int nx = gnext(n); + if (nx == 0) + return luaO_nilobject; /* not found */ + n += nx; + } + } +} + + +const TValue *luaH_getstr (Table *t, TString *key) { + if (key->tt == LUA_TSHRSTR) + return luaH_getshortstr(t, key); + else { /* for long strings, use generic case */ + TValue ko; + setsvalue(cast(lua_State *, NULL), &ko, key); + return getgeneric(t, &ko); + } } @@ -480,25 +588,17 @@ const TValue *luaH_getstr (Table *t, TString *key) { */ const TValue *luaH_get (Table *t, const TValue *key) { switch (ttype(key)) { - case LUA_TSHRSTR: return luaH_getstr(t, rawtsvalue(key)); + case LUA_TSHRSTR: return luaH_getshortstr(t, tsvalue(key)); + case LUA_TNUMINT: return luaH_getint(t, ivalue(key)); case LUA_TNIL: return luaO_nilobject; - case LUA_TNUMBER: { - int k; - lua_Number n = nvalue(key); - lua_number2int(k, n); - if (luai_numeq(cast_num(k), n)) /* index is int? */ + case LUA_TNUMFLT: { + lua_Integer k; + if (luaV_tointeger(key, &k, 0)) /* index is int? */ return luaH_getint(t, k); /* use specialized version */ - /* else go through */ - } - default: { - Node *n = mainposition(t, key); - do { /* check whether `key' is somewhere in the chain */ - if (luaV_rawequalobj(gkey(n), key)) - return gval(n); /* that's it */ - else n = gnext(n); - } while (n); - return luaO_nilobject; - } + /* else... */ + } /* FALLTHROUGH */ + default: + return getgeneric(t, key); } } @@ -515,37 +615,37 @@ TValue *luaH_set (lua_State *L, Table *t, const TValue *key) { } -void luaH_setint (lua_State *L, Table *t, int key, TValue *value) { +void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) { const TValue *p = luaH_getint(t, key); TValue *cell; if (p != luaO_nilobject) cell = cast(TValue *, p); else { TValue k; - setnvalue(&k, cast_num(key)); + setivalue(&k, key); cell = luaH_newkey(L, t, &k); } setobj2t(L, cell, value); } -static int unbound_search (Table *t, unsigned int j) { - unsigned int i = j; /* i is zero or a present index */ +static lua_Unsigned unbound_search (Table *t, lua_Unsigned j) { + lua_Unsigned i = j; /* i is zero or a present index */ j++; - /* find `i' and `j' such that i is present and j is not */ + /* find 'i' and 'j' such that i is present and j is not */ while (!ttisnil(luaH_getint(t, j))) { i = j; - j *= 2; - if (j > cast(unsigned int, MAX_INT)) { /* overflow? */ + if (j > l_castS2U(LUA_MAXINTEGER) / 2) { /* overflow? */ /* table was built with bad purposes: resort to linear search */ i = 1; while (!ttisnil(luaH_getint(t, i))) i++; return i - 1; } + j *= 2; } /* now do a binary search between them */ while (j - i > 1) { - unsigned int m = (i+j)/2; + lua_Unsigned m = (i+j)/2; if (ttisnil(luaH_getint(t, m))) j = m; else i = m; } @@ -554,10 +654,10 @@ static int unbound_search (Table *t, unsigned int j) { /* -** Try to find a boundary in table `t'. A `boundary' is an integer index +** Try to find a boundary in table 't'. A 'boundary' is an integer index ** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil). */ -int luaH_getn (Table *t) { +lua_Unsigned luaH_getn (Table *t) { unsigned int j = t->sizearray; if (j > 0 && ttisnil(&t->array[j - 1])) { /* there is a boundary in the array part: (binary) search for it */ @@ -570,7 +670,7 @@ int luaH_getn (Table *t) { return i; } /* else must find a boundary in hash part */ - else if (isdummy(t->node)) /* hash part is empty? */ + else if (isdummy(t)) /* hash part is empty? */ return j; /* that is easy... */ else return unbound_search(t, j); } @@ -583,6 +683,6 @@ Node *luaH_mainposition (const Table *t, const TValue *key) { return mainposition(t, key); } -int luaH_isdummy (Node *n) { return isdummy(n); } +int luaH_isdummy (const Table *t) { return isdummy(t); } #endif diff --git a/depends/lua/src/ltablib.c b/depends/lua/src/ltablib.c index 6001224e39..c5349578ec 100644 --- a/depends/lua/src/ltablib.c +++ b/depends/lua/src/ltablib.c @@ -1,23 +1,61 @@ /* -** $Id: ltablib.c,v 1.65.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: ltablib.c,v 1.93.1.1 2017/04/19 17:20:42 roberto Exp $ ** Library for Table Manipulation ** See Copyright Notice in lua.h */ - -#include - #define ltablib_c #define LUA_LIB +#include "lprefix.h" + + +#include +#include +#include + #include "lua.h" #include "lauxlib.h" #include "lualib.h" -#define aux_getn(L,n) (luaL_checktype(L, n, LUA_TTABLE), luaL_len(L, n)) +/* +** Operations that an object must define to mimic a table +** (some functions only need some of them) +*/ +#define TAB_R 1 /* read */ +#define TAB_W 2 /* write */ +#define TAB_L 4 /* length */ +#define TAB_RW (TAB_R | TAB_W) /* read/write */ + + +#define aux_getn(L,n,w) (checktab(L, n, (w) | TAB_L), luaL_len(L, n)) + +static int checkfield (lua_State *L, const char *key, int n) { + lua_pushstring(L, key); + return (lua_rawget(L, -n) != LUA_TNIL); +} + + +/* +** Check that 'arg' either is a table or can behave like one (that is, +** has a metatable with the required metamethods) +*/ +static void checktab (lua_State *L, int arg, int what) { + if (lua_type(L, arg) != LUA_TTABLE) { /* is it not a table? */ + int n = 1; /* number of elements to pop */ + if (lua_getmetatable(L, arg) && /* must have metatable */ + (!(what & TAB_R) || checkfield(L, "__index", ++n)) && + (!(what & TAB_W) || checkfield(L, "__newindex", ++n)) && + (!(what & TAB_L) || checkfield(L, "__len", ++n))) { + lua_pop(L, n); /* pop metatable and tested metamethods */ + } + else + luaL_checktype(L, arg, LUA_TTABLE); /* force an error */ + } +} #if defined(LUA_COMPAT_MAXN) @@ -39,65 +77,102 @@ static int maxn (lua_State *L) { static int tinsert (lua_State *L) { - int e = aux_getn(L, 1) + 1; /* first empty element */ - int pos; /* where to insert new element */ + lua_Integer e = aux_getn(L, 1, TAB_RW) + 1; /* first empty element */ + lua_Integer pos; /* where to insert new element */ switch (lua_gettop(L)) { case 2: { /* called with only 2 arguments */ pos = e; /* insert new element at the end */ break; } case 3: { - int i; - pos = luaL_checkint(L, 2); /* 2nd argument is the position */ + lua_Integer i; + pos = luaL_checkinteger(L, 2); /* 2nd argument is the position */ luaL_argcheck(L, 1 <= pos && pos <= e, 2, "position out of bounds"); for (i = e; i > pos; i--) { /* move up elements */ - lua_rawgeti(L, 1, i-1); - lua_rawseti(L, 1, i); /* t[i] = t[i-1] */ + lua_geti(L, 1, i - 1); + lua_seti(L, 1, i); /* t[i] = t[i - 1] */ } break; } default: { - return luaL_error(L, "wrong number of arguments to " LUA_QL("insert")); + return luaL_error(L, "wrong number of arguments to 'insert'"); } } - lua_rawseti(L, 1, pos); /* t[pos] = v */ + lua_seti(L, 1, pos); /* t[pos] = v */ return 0; } static int tremove (lua_State *L) { - int size = aux_getn(L, 1); - int pos = luaL_optint(L, 2, size); + lua_Integer size = aux_getn(L, 1, TAB_RW); + lua_Integer pos = luaL_optinteger(L, 2, size); if (pos != size) /* validate 'pos' if given */ luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds"); - lua_rawgeti(L, 1, pos); /* result = t[pos] */ + lua_geti(L, 1, pos); /* result = t[pos] */ for ( ; pos < size; pos++) { - lua_rawgeti(L, 1, pos+1); - lua_rawseti(L, 1, pos); /* t[pos] = t[pos+1] */ + lua_geti(L, 1, pos + 1); + lua_seti(L, 1, pos); /* t[pos] = t[pos + 1] */ } lua_pushnil(L); - lua_rawseti(L, 1, pos); /* t[pos] = nil */ + lua_seti(L, 1, pos); /* t[pos] = nil */ return 1; } -static void addfield (lua_State *L, luaL_Buffer *b, int i) { - lua_rawgeti(L, 1, i); +/* +** Copy elements (1[f], ..., 1[e]) into (tt[t], tt[t+1], ...). Whenever +** possible, copy in increasing order, which is better for rehashing. +** "possible" means destination after original range, or smaller +** than origin, or copying to another table. +*/ +static int tmove (lua_State *L) { + lua_Integer f = luaL_checkinteger(L, 2); + lua_Integer e = luaL_checkinteger(L, 3); + lua_Integer t = luaL_checkinteger(L, 4); + int tt = !lua_isnoneornil(L, 5) ? 5 : 1; /* destination table */ + checktab(L, 1, TAB_R); + checktab(L, tt, TAB_W); + if (e >= f) { /* otherwise, nothing to move */ + lua_Integer n, i; + luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3, + "too many elements to move"); + n = e - f + 1; /* number of elements to move */ + luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4, + "destination wrap around"); + if (t > e || t <= f || (tt != 1 && !lua_compare(L, 1, tt, LUA_OPEQ))) { + for (i = 0; i < n; i++) { + lua_geti(L, 1, f + i); + lua_seti(L, tt, t + i); + } + } + else { + for (i = n - 1; i >= 0; i--) { + lua_geti(L, 1, f + i); + lua_seti(L, tt, t + i); + } + } + } + lua_pushvalue(L, tt); /* return destination table */ + return 1; +} + + +static void addfield (lua_State *L, luaL_Buffer *b, lua_Integer i) { + lua_geti(L, 1, i); if (!lua_isstring(L, -1)) - luaL_error(L, "invalid value (%s) at index %d in table for " - LUA_QL("concat"), luaL_typename(L, -1), i); + luaL_error(L, "invalid value (%s) at index %d in table for 'concat'", + luaL_typename(L, -1), i); luaL_addvalue(b); } static int tconcat (lua_State *L) { luaL_Buffer b; + lua_Integer last = aux_getn(L, 1, TAB_R); size_t lsep; - int i, last; const char *sep = luaL_optlstring(L, 2, "", &lsep); - luaL_checktype(L, 1, LUA_TTABLE); - i = luaL_optint(L, 3, 1); - last = luaL_opt(L, luaL_checkint, 4, luaL_len(L, 1)); + lua_Integer i = luaL_optinteger(L, 3, 1); + last = luaL_optinteger(L, 4, last); luaL_buffinit(L, &b); for (; i < last; i++) { addfield(L, &b, i); @@ -117,35 +192,31 @@ static int tconcat (lua_State *L) { */ static int pack (lua_State *L) { + int i; int n = lua_gettop(L); /* number of elements to pack */ lua_createtable(L, n, 1); /* create result table */ + lua_insert(L, 1); /* put it at index 1 */ + for (i = n; i >= 1; i--) /* assign elements */ + lua_seti(L, 1, i); lua_pushinteger(L, n); - lua_setfield(L, -2, "n"); /* t.n = number of elements */ - if (n > 0) { /* at least one element? */ - int i; - lua_pushvalue(L, 1); - lua_rawseti(L, -2, 1); /* insert first element */ - lua_replace(L, 1); /* move table into index 1 */ - for (i = n; i >= 2; i--) /* assign other elements */ - lua_rawseti(L, 1, i); - } + lua_setfield(L, 1, "n"); /* t.n = number of elements */ return 1; /* return table */ } static int unpack (lua_State *L) { - int i, e, n; - luaL_checktype(L, 1, LUA_TTABLE); - i = luaL_optint(L, 2, 1); - e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1)); + lua_Unsigned n; + lua_Integer i = luaL_optinteger(L, 2, 1); + lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1)); if (i > e) return 0; /* empty range */ - n = e - i + 1; /* number of elements */ - if (n <= 0 || !lua_checkstack(L, n)) /* n <= 0 means arith. overflow */ + n = (lua_Unsigned)e - i; /* number of elements minus 1 (avoid overflows) */ + if (n >= (unsigned int)INT_MAX || !lua_checkstack(L, (int)(++n))) return luaL_error(L, "too many results to unpack"); - lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */ - while (i++ < e) /* push arg[i + 1...e] */ - lua_rawgeti(L, 1, i); - return n; + for (; i < e; i++) { /* push arg[i..e - 1] (to avoid overflows) */ + lua_geti(L, 1, i); + } + lua_geti(L, 1, e); /* push last element */ + return (int)n; } /* }====================================================== */ @@ -155,102 +226,197 @@ static int unpack (lua_State *L) { /* ** {====================================================== ** Quicksort -** (based on `Algorithms in MODULA-3', Robert Sedgewick; +** (based on 'Algorithms in MODULA-3', Robert Sedgewick; ** Addison-Wesley, 1993.) ** ======================================================= */ -static void set2 (lua_State *L, int i, int j) { - lua_rawseti(L, 1, i); - lua_rawseti(L, 1, j); +/* type for array indices */ +typedef unsigned int IdxT; + + +/* +** Produce a "random" 'unsigned int' to randomize pivot choice. This +** macro is used only when 'sort' detects a big imbalance in the result +** of a partition. (If you don't want/need this "randomness", ~0 is a +** good choice.) +*/ +#if !defined(l_randomizePivot) /* { */ + +#include + +/* size of 'e' measured in number of 'unsigned int's */ +#define sof(e) (sizeof(e) / sizeof(unsigned int)) + +/* +** Use 'time' and 'clock' as sources of "randomness". Because we don't +** know the types 'clock_t' and 'time_t', we cannot cast them to +** anything without risking overflows. A safe way to use their values +** is to copy them to an array of a known type and use the array values. +*/ +static unsigned int l_randomizePivot (void) { + clock_t c = clock(); + time_t t = time(NULL); + unsigned int buff[sof(c) + sof(t)]; + unsigned int i, rnd = 0; + memcpy(buff, &c, sof(c) * sizeof(unsigned int)); + memcpy(buff + sof(c), &t, sof(t) * sizeof(unsigned int)); + for (i = 0; i < sof(buff); i++) + rnd += buff[i]; + return rnd; +} + +#endif /* } */ + + +/* arrays larger than 'RANLIMIT' may use randomized pivots */ +#define RANLIMIT 100u + + +static void set2 (lua_State *L, IdxT i, IdxT j) { + lua_seti(L, 1, i); + lua_seti(L, 1, j); } + +/* +** Return true iff value at stack index 'a' is less than the value at +** index 'b' (according to the order of the sort). +*/ static int sort_comp (lua_State *L, int a, int b) { - if (!lua_isnil(L, 2)) { /* function? */ + if (lua_isnil(L, 2)) /* no function? */ + return lua_compare(L, a, b, LUA_OPLT); /* a < b */ + else { /* function */ int res; - lua_pushvalue(L, 2); + lua_pushvalue(L, 2); /* push function */ lua_pushvalue(L, a-1); /* -1 to compensate function */ - lua_pushvalue(L, b-2); /* -2 to compensate function and `a' */ - lua_call(L, 2, 1); - res = lua_toboolean(L, -1); - lua_pop(L, 1); + lua_pushvalue(L, b-2); /* -2 to compensate function and 'a' */ + lua_call(L, 2, 1); /* call function */ + res = lua_toboolean(L, -1); /* get result */ + lua_pop(L, 1); /* pop result */ return res; } - else /* a < b? */ - return lua_compare(L, a, b, LUA_OPLT); } -static void auxsort (lua_State *L, int l, int u) { - while (l < u) { /* for tail recursion */ - int i, j; - /* sort elements a[l], a[(l+u)/2] and a[u] */ - lua_rawgeti(L, 1, l); - lua_rawgeti(L, 1, u); - if (sort_comp(L, -1, -2)) /* a[u] < a[l]? */ - set2(L, l, u); /* swap a[l] - a[u] */ + +/* +** Does the partition: Pivot P is at the top of the stack. +** precondition: a[lo] <= P == a[up-1] <= a[up], +** so it only needs to do the partition from lo + 1 to up - 2. +** Pos-condition: a[lo .. i - 1] <= a[i] == P <= a[i + 1 .. up] +** returns 'i'. +*/ +static IdxT partition (lua_State *L, IdxT lo, IdxT up) { + IdxT i = lo; /* will be incremented before first use */ + IdxT j = up - 1; /* will be decremented before first use */ + /* loop invariant: a[lo .. i] <= P <= a[j .. up] */ + for (;;) { + /* next loop: repeat ++i while a[i] < P */ + while (lua_geti(L, 1, ++i), sort_comp(L, -1, -2)) { + if (i == up - 1) /* a[i] < P but a[up - 1] == P ?? */ + luaL_error(L, "invalid order function for sorting"); + lua_pop(L, 1); /* remove a[i] */ + } + /* after the loop, a[i] >= P and a[lo .. i - 1] < P */ + /* next loop: repeat --j while P < a[j] */ + while (lua_geti(L, 1, --j), sort_comp(L, -3, -1)) { + if (j < i) /* j < i but a[j] > P ?? */ + luaL_error(L, "invalid order function for sorting"); + lua_pop(L, 1); /* remove a[j] */ + } + /* after the loop, a[j] <= P and a[j + 1 .. up] >= P */ + if (j < i) { /* no elements out of place? */ + /* a[lo .. i - 1] <= P <= a[j + 1 .. i .. up] */ + lua_pop(L, 1); /* pop a[j] */ + /* swap pivot (a[up - 1]) with a[i] to satisfy pos-condition */ + set2(L, up - 1, i); + return i; + } + /* otherwise, swap a[i] - a[j] to restore invariant and repeat */ + set2(L, i, j); + } +} + + +/* +** Choose an element in the middle (2nd-3th quarters) of [lo,up] +** "randomized" by 'rnd' +*/ +static IdxT choosePivot (IdxT lo, IdxT up, unsigned int rnd) { + IdxT r4 = (up - lo) / 4; /* range/4 */ + IdxT p = rnd % (r4 * 2) + (lo + r4); + lua_assert(lo + r4 <= p && p <= up - r4); + return p; +} + + +/* +** QuickSort algorithm (recursive function) +*/ +static void auxsort (lua_State *L, IdxT lo, IdxT up, + unsigned int rnd) { + while (lo < up) { /* loop for tail recursion */ + IdxT p; /* Pivot index */ + IdxT n; /* to be used later */ + /* sort elements 'lo', 'p', and 'up' */ + lua_geti(L, 1, lo); + lua_geti(L, 1, up); + if (sort_comp(L, -1, -2)) /* a[up] < a[lo]? */ + set2(L, lo, up); /* swap a[lo] - a[up] */ else - lua_pop(L, 2); - if (u-l == 1) break; /* only 2 elements */ - i = (l+u)/2; - lua_rawgeti(L, 1, i); - lua_rawgeti(L, 1, l); - if (sort_comp(L, -2, -1)) /* a[i]= P */ - while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) { - if (i>=u) luaL_error(L, "invalid order function for sorting"); - lua_pop(L, 1); /* remove a[i] */ - } - /* repeat --j until a[j] <= P */ - while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) { - if (j<=l) luaL_error(L, "invalid order function for sorting"); - lua_pop(L, 1); /* remove a[j] */ - } - if (j n) /* partition too imbalanced? */ + rnd = l_randomizePivot(); /* try a new randomization */ + } /* tail call auxsort(L, lo, up, rnd) */ } + static int sort (lua_State *L) { - int n = aux_getn(L, 1); - luaL_checkstack(L, 40, ""); /* assume array is smaller than 2^40 */ - if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */ - luaL_checktype(L, 2, LUA_TFUNCTION); - lua_settop(L, 2); /* make sure there is two arguments */ - auxsort(L, 1, n); + lua_Integer n = aux_getn(L, 1, TAB_RW); + if (n > 1) { /* non-trivial interval? */ + luaL_argcheck(L, n < INT_MAX, 1, "array too big"); + if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */ + luaL_checktype(L, 2, LUA_TFUNCTION); /* must be a function */ + lua_settop(L, 2); /* make sure there are two arguments */ + auxsort(L, 1, (IdxT)n, 0); + } return 0; } @@ -266,6 +432,7 @@ static const luaL_Reg tab_funcs[] = { {"pack", pack}, {"unpack", unpack}, {"remove", tremove}, + {"move", tmove}, {"sort", sort}, {NULL, NULL} }; diff --git a/depends/lua/src/ltm.c b/depends/lua/src/ltm.c index 69b4ed7727..0e7c713214 100644 --- a/depends/lua/src/ltm.c +++ b/depends/lua/src/ltm.c @@ -1,22 +1,27 @@ /* -** $Id: ltm.c,v 2.14.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: ltm.c,v 2.38.1.1 2017/04/19 17:39:34 roberto Exp $ ** Tag methods ** See Copyright Notice in lua.h */ - -#include - #define ltm_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" +#include "ldebug.h" +#include "ldo.h" #include "lobject.h" #include "lstate.h" #include "lstring.h" #include "ltable.h" #include "ltm.h" +#include "lvm.h" static const char udatatypename[] = "userdata"; @@ -25,7 +30,7 @@ LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = { "no value", "nil", "boolean", udatatypename, "number", "string", "table", "function", udatatypename, "thread", - "proto", "upval" /* these last two cases are used for tests only */ + "proto" /* this last case is used for tests only */ }; @@ -33,14 +38,16 @@ void luaT_init (lua_State *L) { static const char *const luaT_eventname[] = { /* ORDER TM */ "__index", "__newindex", "__gc", "__mode", "__len", "__eq", - "__add", "__sub", "__mul", "__div", "__mod", - "__pow", "__unm", "__lt", "__le", + "__add", "__sub", "__mul", "__mod", "__pow", + "__div", "__idiv", + "__band", "__bor", "__bxor", "__shl", "__shr", + "__unm", "__bnot", "__lt", "__le", "__concat", "__call" }; int i; for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); - luaS_fix(G(L)->tmname[i]); /* never collect these names */ + luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */ } } @@ -50,7 +57,7 @@ void luaT_init (lua_State *L) { ** tag methods */ const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { - const TValue *tm = luaH_getstr(events, ename); + const TValue *tm = luaH_getshortstr(events, ename); lua_assert(event <= TM_EQ); if (ttisnil(tm)) { /* no tag method? */ events->flags |= cast_byte(1u<metatable; break; @@ -70,8 +77,89 @@ const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) { mt = uvalue(o)->metatable; break; default: - mt = G(L)->mt[ttypenv(o)]; + mt = G(L)->mt[ttnov(o)]; + } + return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject); +} + + +/* +** Return the name of the type of an object. For tables and userdata +** with metatable, use their '__name' metafield, if present. +*/ +const char *luaT_objtypename (lua_State *L, const TValue *o) { + Table *mt; + if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || + (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { + const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name")); + if (ttisstring(name)) /* is '__name' a string? */ + return getstr(tsvalue(name)); /* use it as type name */ } - return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject); + return ttypename(ttnov(o)); /* else use standard type name */ +} + + +void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1, + const TValue *p2, TValue *p3, int hasres) { + ptrdiff_t result = savestack(L, p3); + StkId func = L->top; + setobj2s(L, func, f); /* push function (assume EXTRA_STACK) */ + setobj2s(L, func + 1, p1); /* 1st argument */ + setobj2s(L, func + 2, p2); /* 2nd argument */ + L->top += 3; + if (!hasres) /* no result? 'p3' is third argument */ + setobj2s(L, L->top++, p3); /* 3rd argument */ + /* metamethod may yield only when called from Lua code */ + if (isLua(L->ci)) + luaD_call(L, func, hasres); + else + luaD_callnoyield(L, func, hasres); + if (hasres) { /* if has result, move it to its place */ + p3 = restorestack(L, result); + setobjs2s(L, p3, --L->top); + } +} + + +int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2, + StkId res, TMS event) { + const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ + if (ttisnil(tm)) + tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ + if (ttisnil(tm)) return 0; + luaT_callTM(L, tm, p1, p2, res, 1); + return 1; +} + + +void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2, + StkId res, TMS event) { + if (!luaT_callbinTM(L, p1, p2, res, event)) { + switch (event) { + case TM_CONCAT: + luaG_concaterror(L, p1, p2); + /* call never returns, but to avoid warnings: *//* FALLTHROUGH */ + case TM_BAND: case TM_BOR: case TM_BXOR: + case TM_SHL: case TM_SHR: case TM_BNOT: { + lua_Number dummy; + if (tonumber(p1, &dummy) && tonumber(p2, &dummy)) + luaG_tointerror(L, p1, p2); + else + luaG_opinterror(L, p1, p2, "perform bitwise operation on"); + } + /* calls never return, but to avoid warnings: *//* FALLTHROUGH */ + default: + luaG_opinterror(L, p1, p2, "perform arithmetic on"); + } + } +} + + +int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2, + TMS event) { + if (!luaT_callbinTM(L, p1, p2, L->top, event)) + return -1; /* no metamethod */ + else + return !l_isfalse(L->top); } diff --git a/depends/lua/src/lua.c b/depends/lua/src/lua.c index 4345e554e9..ca5b298523 100644 --- a/depends/lua/src/lua.c +++ b/depends/lua/src/lua.c @@ -1,23 +1,26 @@ /* -** $Id: lua.c,v 1.206.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lua.c,v 1.230.1.1 2017/04/19 17:29:57 roberto Exp $ ** Lua stand-alone interpreter ** See Copyright Notice in lua.h */ +#define lua_c + +#include "lprefix.h" + #include #include #include #include -#define lua_c - #include "lua.h" #include "lauxlib.h" #include "lualib.h" + #if !defined(LUA_PROMPT) #define LUA_PROMPT "> " #define LUA_PROMPT2 ">> " @@ -31,28 +34,39 @@ #define LUA_MAXINPUT 512 #endif -#if !defined(LUA_INIT) -#define LUA_INIT "LUA_INIT" +#if !defined(LUA_INIT_VAR) +#define LUA_INIT_VAR "LUA_INIT" #endif -#define LUA_INITVERSION \ - LUA_INIT "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR +#define LUA_INITVARVERSION LUA_INIT_VAR LUA_VERSUFFIX /* ** lua_stdin_is_tty detects whether the standard input is a 'tty' (that ** is, whether we're running lua interactively). */ -#if defined(LUA_USE_ISATTY) +#if !defined(lua_stdin_is_tty) /* { */ + +#if defined(LUA_USE_POSIX) /* { */ + #include #define lua_stdin_is_tty() isatty(0) -#elif defined(LUA_WIN) + +#elif defined(LUA_USE_WINDOWS) /* }{ */ + #include -#include +#include + #define lua_stdin_is_tty() _isatty(_fileno(stdin)) -#else + +#else /* }{ */ + +/* ISO C definition */ #define lua_stdin_is_tty() 1 /* assume stdin is a tty */ -#endif + +#endif /* } */ + +#endif /* } */ /* @@ -61,26 +75,27 @@ ** lua_saveline defines how to "save" a read line in a "history". ** lua_freeline defines how to free a line read by lua_readline. */ -#if defined(LUA_USE_READLINE) +#if !defined(lua_readline) /* { */ + +#if defined(LUA_USE_READLINE) /* { */ -#include #include #include #define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL) -#define lua_saveline(L,idx) \ - if (lua_rawlen(L,idx) > 0) /* non-empty line? */ \ - add_history(lua_tostring(L, idx)); /* add it to history */ +#define lua_saveline(L,line) ((void)L, add_history(line)) #define lua_freeline(L,b) ((void)L, free(b)) -#elif !defined(lua_readline) +#else /* }{ */ #define lua_readline(L,b,p) \ ((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \ fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */ -#define lua_saveline(L,idx) { (void)L; (void)idx; } +#define lua_saveline(L,line) { (void)L; (void)line; } #define lua_freeline(L,b) { (void)L; (void)b; } -#endif +#endif /* } */ + +#endif /* } */ @@ -90,33 +105,40 @@ static lua_State *globalL = NULL; static const char *progname = LUA_PROGNAME; - +/* +** Hook set by signal function to stop the interpreter. +*/ static void lstop (lua_State *L, lua_Debug *ar) { (void)ar; /* unused arg. */ - lua_sethook(L, NULL, 0, 0); + lua_sethook(L, NULL, 0, 0); /* reset hook */ luaL_error(L, "interrupted!"); } +/* +** Function to be called at a C signal. Because a C signal cannot +** just change a Lua state (as there is no proper synchronization), +** this function only sets a hook that, when called, will stop the +** interpreter. +*/ static void laction (int i) { - signal(i, SIG_DFL); /* if another SIGINT happens before lstop, - terminate process (default action) */ + signal(i, SIG_DFL); /* if another SIGINT happens, terminate process */ lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1); } static void print_usage (const char *badoption) { - luai_writestringerror("%s: ", progname); + lua_writestringerror("%s: ", progname); if (badoption[1] == 'e' || badoption[1] == 'l') - luai_writestringerror("'%s' needs argument\n", badoption); + lua_writestringerror("'%s' needs argument\n", badoption); else - luai_writestringerror("unrecognized option '%s'\n", badoption); - luai_writestringerror( + lua_writestringerror("unrecognized option '%s'\n", badoption); + lua_writestringerror( "usage: %s [options] [script [args]]\n" "Available options are:\n" - " -e stat execute string " LUA_QL("stat") "\n" - " -i enter interactive mode after executing " LUA_QL("script") "\n" - " -l name require library " LUA_QL("name") "\n" + " -e stat execute string 'stat'\n" + " -i enter interactive mode after executing 'script'\n" + " -l name require library 'name' into global 'name'\n" " -v show version information\n" " -E ignore environment variables\n" " -- stop handling options\n" @@ -126,101 +148,114 @@ static void print_usage (const char *badoption) { } +/* +** Prints an error message, adding the program name in front of it +** (if present) +*/ static void l_message (const char *pname, const char *msg) { - if (pname) luai_writestringerror("%s: ", pname); - luai_writestringerror("%s\n", msg); + if (pname) lua_writestringerror("%s: ", pname); + lua_writestringerror("%s\n", msg); } +/* +** Check whether 'status' is not OK and, if so, prints the error +** message on the top of the stack. It assumes that the error object +** is a string, as it was either generated by Lua or by 'msghandler'. +*/ static int report (lua_State *L, int status) { - if (status != LUA_OK && !lua_isnil(L, -1)) { + if (status != LUA_OK) { const char *msg = lua_tostring(L, -1); - if (msg == NULL) msg = "(error object is not a string)"; l_message(progname, msg); - lua_pop(L, 1); - /* force a complete garbage collection in case of errors */ - lua_gc(L, LUA_GCCOLLECT, 0); + lua_pop(L, 1); /* remove message */ } return status; } -/* the next function is called unprotected, so it must avoid errors */ -static void finalreport (lua_State *L, int status) { - if (status != LUA_OK) { - const char *msg = (lua_type(L, -1) == LUA_TSTRING) ? lua_tostring(L, -1) - : NULL; - if (msg == NULL) msg = "(error object is not a string)"; - l_message(progname, msg); - lua_pop(L, 1); - } -} - - -static int traceback (lua_State *L) { +/* +** Message handler used to run all chunks +*/ +static int msghandler (lua_State *L) { const char *msg = lua_tostring(L, 1); - if (msg) - luaL_traceback(L, L, msg, 1); - else if (!lua_isnoneornil(L, 1)) { /* is there an error object? */ - if (!luaL_callmeta(L, 1, "__tostring")) /* try its 'tostring' metamethod */ - lua_pushliteral(L, "(no error message)"); + if (msg == NULL) { /* is error object not a string? */ + if (luaL_callmeta(L, 1, "__tostring") && /* does it have a metamethod */ + lua_type(L, -1) == LUA_TSTRING) /* that produces a string? */ + return 1; /* that is the message */ + else + msg = lua_pushfstring(L, "(error object is a %s value)", + luaL_typename(L, 1)); } - return 1; + luaL_traceback(L, L, msg, 1); /* append a standard traceback */ + return 1; /* return the traceback */ } +/* +** Interface to 'lua_pcall', which sets appropriate message function +** and C-signal handler. Used to run all chunks. +*/ static int docall (lua_State *L, int narg, int nres) { int status; int base = lua_gettop(L) - narg; /* function index */ - lua_pushcfunction(L, traceback); /* push traceback function */ - lua_insert(L, base); /* put it under chunk and args */ + lua_pushcfunction(L, msghandler); /* push message handler */ + lua_insert(L, base); /* put it under function and args */ globalL = L; /* to be available to 'laction' */ - signal(SIGINT, laction); + signal(SIGINT, laction); /* set C-signal handler */ status = lua_pcall(L, narg, nres, base); - signal(SIGINT, SIG_DFL); - lua_remove(L, base); /* remove traceback function */ + signal(SIGINT, SIG_DFL); /* reset C-signal handler */ + lua_remove(L, base); /* remove message handler from the stack */ return status; } static void print_version (void) { - luai_writestring(LUA_COPYRIGHT, strlen(LUA_COPYRIGHT)); - luai_writeline(); + lua_writestring(LUA_COPYRIGHT, strlen(LUA_COPYRIGHT)); + lua_writeline(); } -static int getargs (lua_State *L, char **argv, int n) { - int narg; - int i; - int argc = 0; - while (argv[argc]) argc++; /* count total number of arguments */ - narg = argc - (n + 1); /* number of arguments to the script */ - luaL_checkstack(L, narg + 3, "too many arguments to script"); - for (i=n+1; i < argc; i++) - lua_pushstring(L, argv[i]); - lua_createtable(L, narg, n + 1); - for (i=0; i < argc; i++) { +/* +** Create the 'arg' table, which stores all arguments from the +** command line ('argv'). It should be aligned so that, at index 0, +** it has 'argv[script]', which is the script name. The arguments +** to the script (everything after 'script') go to positive indices; +** other arguments (before the script name) go to negative indices. +** If there is no script name, assume interpreter's name as base. +*/ +static void createargtable (lua_State *L, char **argv, int argc, int script) { + int i, narg; + if (script == argc) script = 0; /* no script name? */ + narg = argc - (script + 1); /* number of positive indices */ + lua_createtable(L, narg, script + 1); + for (i = 0; i < argc; i++) { lua_pushstring(L, argv[i]); - lua_rawseti(L, -2, i - n); + lua_rawseti(L, -2, i - script); } - return narg; + lua_setglobal(L, "arg"); } -static int dofile (lua_State *L, const char *name) { - int status = luaL_loadfile(L, name); +static int dochunk (lua_State *L, int status) { if (status == LUA_OK) status = docall(L, 0, 0); return report(L, status); } +static int dofile (lua_State *L, const char *name) { + return dochunk(L, luaL_loadfile(L, name)); +} + + static int dostring (lua_State *L, const char *s, const char *name) { - int status = luaL_loadbuffer(L, s, strlen(s), name); - if (status == LUA_OK) status = docall(L, 0, 0); - return report(L, status); + return dochunk(L, luaL_loadbuffer(L, s, strlen(s), name)); } +/* +** Calls 'require(name)' and stores the result in a global variable +** with the given name. +*/ static int dolibrary (lua_State *L, const char *name) { int status; lua_getglobal(L, "require"); @@ -232,6 +267,9 @@ static int dolibrary (lua_State *L, const char *name) { } +/* +** Returns the string to be used as a prompt by the interpreter. +*/ static const char *get_prompt (lua_State *L, int firstline) { const char *p; lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2"); @@ -244,6 +282,12 @@ static const char *get_prompt (lua_State *L, int firstline) { #define EOFMARK "" #define marklen (sizeof(EOFMARK)/sizeof(char) - 1) + +/* +** Check whether 'status' signals a syntax error and the error +** message at the top of the stack ends with the above mark for +** incomplete statements. +*/ static int incomplete (lua_State *L, int status) { if (status == LUA_ERRSYNTAX) { size_t lmsg; @@ -257,174 +301,242 @@ static int incomplete (lua_State *L, int status) { } +/* +** Prompt the user, read a line, and push it into the Lua stack. +*/ static int pushline (lua_State *L, int firstline) { char buffer[LUA_MAXINPUT]; char *b = buffer; size_t l; const char *prmt = get_prompt(L, firstline); int readstatus = lua_readline(L, b, prmt); - lua_pop(L, 1); /* remove result from 'get_prompt' */ if (readstatus == 0) - return 0; /* no input */ + return 0; /* no input (prompt will be popped by caller) */ + lua_pop(L, 1); /* remove prompt */ l = strlen(b); if (l > 0 && b[l-1] == '\n') /* line ends with newline? */ - b[l-1] = '\0'; /* remove it */ - if (firstline && b[0] == '=') /* first line starts with `=' ? */ - lua_pushfstring(L, "return %s", b+1); /* change it to `return' */ + b[--l] = '\0'; /* remove it */ + if (firstline && b[0] == '=') /* for compatibility with 5.2, ... */ + lua_pushfstring(L, "return %s", b + 1); /* change '=' to 'return' */ else - lua_pushstring(L, b); + lua_pushlstring(L, b, l); lua_freeline(L, b); return 1; } +/* +** Try to compile line on the stack as 'return ;'; on return, stack +** has either compiled chunk or original line (if compilation failed). +*/ +static int addreturn (lua_State *L) { + const char *line = lua_tostring(L, -1); /* original line */ + const char *retline = lua_pushfstring(L, "return %s;", line); + int status = luaL_loadbuffer(L, retline, strlen(retline), "=stdin"); + if (status == LUA_OK) { + lua_remove(L, -2); /* remove modified line */ + if (line[0] != '\0') /* non empty? */ + lua_saveline(L, line); /* keep history */ + } + else + lua_pop(L, 2); /* pop result from 'luaL_loadbuffer' and modified line */ + return status; +} + + +/* +** Read multiple lines until a complete Lua statement +*/ +static int multiline (lua_State *L) { + for (;;) { /* repeat until gets a complete statement */ + size_t len; + const char *line = lua_tolstring(L, 1, &len); /* get what it has */ + int status = luaL_loadbuffer(L, line, len, "=stdin"); /* try it */ + if (!incomplete(L, status) || !pushline(L, 0)) { + lua_saveline(L, line); /* keep history */ + return status; /* cannot or should not try to add continuation line */ + } + lua_pushliteral(L, "\n"); /* add newline... */ + lua_insert(L, -2); /* ...between the two lines */ + lua_concat(L, 3); /* join them */ + } +} + + +/* +** Read a line and try to load (compile) it first as an expression (by +** adding "return " in front of it) and second as a statement. Return +** the final status of load/call with the resulting function (if any) +** in the top of the stack. +*/ static int loadline (lua_State *L) { int status; lua_settop(L, 0); if (!pushline(L, 1)) return -1; /* no input */ - for (;;) { /* repeat until gets a complete line */ - size_t l; - const char *line = lua_tolstring(L, 1, &l); - status = luaL_loadbuffer(L, line, l, "=stdin"); - if (!incomplete(L, status)) break; /* cannot try to add lines? */ - if (!pushline(L, 0)) /* no more input? */ - return -1; - lua_pushliteral(L, "\n"); /* add a new line... */ - lua_insert(L, -2); /* ...between the two lines */ - lua_concat(L, 3); /* join them */ - } - lua_saveline(L, 1); - lua_remove(L, 1); /* remove line */ + if ((status = addreturn(L)) != LUA_OK) /* 'return ...' did not work? */ + status = multiline(L); /* try as command, maybe with continuation lines */ + lua_remove(L, 1); /* remove line from the stack */ + lua_assert(lua_gettop(L) == 1); return status; } -static void dotty (lua_State *L) { +/* +** Prints (calling the Lua 'print' function) any values on the stack +*/ +static void l_print (lua_State *L) { + int n = lua_gettop(L); + if (n > 0) { /* any result to be printed? */ + luaL_checkstack(L, LUA_MINSTACK, "too many results to print"); + lua_getglobal(L, "print"); + lua_insert(L, 1); + if (lua_pcall(L, n, 0, 0) != LUA_OK) + l_message(progname, lua_pushfstring(L, "error calling 'print' (%s)", + lua_tostring(L, -1))); + } +} + + +/* +** Do the REPL: repeatedly read (load) a line, evaluate (call) it, and +** print any results. +*/ +static void doREPL (lua_State *L) { int status; const char *oldprogname = progname; - progname = NULL; + progname = NULL; /* no 'progname' on errors in interactive mode */ while ((status = loadline(L)) != -1) { - if (status == LUA_OK) status = docall(L, 0, LUA_MULTRET); - report(L, status); - if (status == LUA_OK && lua_gettop(L) > 0) { /* any result to print? */ - luaL_checkstack(L, LUA_MINSTACK, "too many results to print"); - lua_getglobal(L, "print"); - lua_insert(L, 1); - if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != LUA_OK) - l_message(progname, lua_pushfstring(L, - "error calling " LUA_QL("print") " (%s)", - lua_tostring(L, -1))); - } + if (status == LUA_OK) + status = docall(L, 0, LUA_MULTRET); + if (status == LUA_OK) l_print(L); + else report(L, status); } lua_settop(L, 0); /* clear stack */ - luai_writeline(); + lua_writeline(); progname = oldprogname; } -static int handle_script (lua_State *L, char **argv, int n) { +/* +** Push on the stack the contents of table 'arg' from 1 to #arg +*/ +static int pushargs (lua_State *L) { + int i, n; + if (lua_getglobal(L, "arg") != LUA_TTABLE) + luaL_error(L, "'arg' is not a table"); + n = (int)luaL_len(L, -1); + luaL_checkstack(L, n + 3, "too many arguments to script"); + for (i = 1; i <= n; i++) + lua_rawgeti(L, -i, i); + lua_remove(L, -i); /* remove table from the stack */ + return n; +} + + +static int handle_script (lua_State *L, char **argv) { int status; - const char *fname; - int narg = getargs(L, argv, n); /* collect arguments */ - lua_setglobal(L, "arg"); - fname = argv[n]; - if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0) + const char *fname = argv[0]; + if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0) fname = NULL; /* stdin */ status = luaL_loadfile(L, fname); - lua_insert(L, -(narg+1)); - if (status == LUA_OK) - status = docall(L, narg, LUA_MULTRET); - else - lua_pop(L, narg); + if (status == LUA_OK) { + int n = pushargs(L); /* push arguments to script */ + status = docall(L, n, LUA_MULTRET); + } return report(L, status); } -/* check that argument has no extra characters at the end */ -#define noextrachars(x) {if ((x)[2] != '\0') return -1;} +/* bits of various argument indicators in 'args' */ +#define has_error 1 /* bad option */ +#define has_i 2 /* -i */ +#define has_v 4 /* -v */ +#define has_e 8 /* -e */ +#define has_E 16 /* -E */ -/* indices of various argument indicators in array args */ -#define has_i 0 /* -i */ -#define has_v 1 /* -v */ -#define has_e 2 /* -e */ -#define has_E 3 /* -E */ - -#define num_has 4 /* number of 'has_*' */ - - -static int collectargs (char **argv, int *args) { +/* +** Traverses all arguments from 'argv', returning a mask with those +** needed before running any Lua code (or an error code if it finds +** any invalid argument). 'first' returns the first not-handled argument +** (either the script name or a bad argument in case of error). +*/ +static int collectargs (char **argv, int *first) { + int args = 0; int i; for (i = 1; argv[i] != NULL; i++) { + *first = i; if (argv[i][0] != '-') /* not an option? */ - return i; - switch (argv[i][1]) { /* option */ - case '-': - noextrachars(argv[i]); - return (argv[i+1] != NULL ? i+1 : 0); - case '\0': - return i; + return args; /* stop handling options */ + switch (argv[i][1]) { /* else check option */ + case '-': /* '--' */ + if (argv[i][2] != '\0') /* extra characters after '--'? */ + return has_error; /* invalid option */ + *first = i + 1; + return args; + case '\0': /* '-' */ + return args; /* script "name" is '-' */ case 'E': - args[has_E] = 1; + if (argv[i][2] != '\0') /* extra characters after 1st? */ + return has_error; /* invalid option */ + args |= has_E; break; case 'i': - noextrachars(argv[i]); - args[has_i] = 1; /* go through */ + args |= has_i; /* (-i implies -v) *//* FALLTHROUGH */ case 'v': - noextrachars(argv[i]); - args[has_v] = 1; + if (argv[i][2] != '\0') /* extra characters after 1st? */ + return has_error; /* invalid option */ + args |= has_v; break; case 'e': - args[has_e] = 1; /* go through */ + args |= has_e; /* FALLTHROUGH */ case 'l': /* both options need an argument */ if (argv[i][2] == '\0') { /* no concatenated argument? */ i++; /* try next 'argv' */ if (argv[i] == NULL || argv[i][0] == '-') - return -(i - 1); /* no next argument or it is another option */ + return has_error; /* no next argument or it is another option */ } break; - default: /* invalid option; return its index... */ - return -i; /* ...as a negative value */ + default: /* invalid option */ + return has_error; } } - return 0; + *first = i; /* no script name */ + return args; } +/* +** Processes options 'e' and 'l', which involve running Lua code. +** Returns 0 if some code raises an error. +*/ static int runargs (lua_State *L, char **argv, int n) { int i; for (i = 1; i < n; i++) { - lua_assert(argv[i][0] == '-'); - switch (argv[i][1]) { /* option */ - case 'e': { - const char *chunk = argv[i] + 2; - if (*chunk == '\0') chunk = argv[++i]; - lua_assert(chunk != NULL); - if (dostring(L, chunk, "=(command line)") != LUA_OK) - return 0; - break; - } - case 'l': { - const char *filename = argv[i] + 2; - if (*filename == '\0') filename = argv[++i]; - lua_assert(filename != NULL); - if (dolibrary(L, filename) != LUA_OK) - return 0; /* stop if file fails */ - break; - } - default: break; + int option = argv[i][1]; + lua_assert(argv[i][0] == '-'); /* already checked */ + if (option == 'e' || option == 'l') { + int status; + const char *extra = argv[i] + 2; /* both options need an argument */ + if (*extra == '\0') extra = argv[++i]; + lua_assert(extra != NULL); + status = (option == 'e') + ? dostring(L, extra, "=(command line)") + : dolibrary(L, extra); + if (status != LUA_OK) return 0; } } return 1; } + static int handle_luainit (lua_State *L) { - const char *name = "=" LUA_INITVERSION; + const char *name = "=" LUA_INITVARVERSION; const char *init = getenv(name + 1); if (init == NULL) { - name = "=" LUA_INIT; + name = "=" LUA_INIT_VAR; init = getenv(name + 1); /* try alternative name */ } if (init == NULL) return LUA_OK; @@ -435,40 +547,44 @@ static int handle_luainit (lua_State *L) { } +/* +** Main body of stand-alone interpreter (to be called in protected mode). +** Reads the options and handles them all. +*/ static int pmain (lua_State *L) { int argc = (int)lua_tointeger(L, 1); char **argv = (char **)lua_touserdata(L, 2); int script; - int args[num_has]; - args[has_i] = args[has_v] = args[has_e] = args[has_E] = 0; + int args = collectargs(argv, &script); + luaL_checkversion(L); /* check that interpreter has correct version */ if (argv[0] && argv[0][0]) progname = argv[0]; - script = collectargs(argv, args); - if (script < 0) { /* invalid arg? */ - print_usage(argv[-script]); + if (args == has_error) { /* bad arg? */ + print_usage(argv[script]); /* 'script' has index of bad arg. */ return 0; } - if (args[has_v]) print_version(); - if (args[has_E]) { /* option '-E'? */ + if (args & has_v) /* option '-v'? */ + print_version(); + if (args & has_E) { /* option '-E'? */ lua_pushboolean(L, 1); /* signal for libraries to ignore env. vars. */ lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV"); } - /* open standard libraries */ - luaL_checkversion(L); - lua_gc(L, LUA_GCSTOP, 0); /* stop collector during initialization */ - luaL_openlibs(L); /* open libraries */ - lua_gc(L, LUA_GCRESTART, 0); - if (!args[has_E] && handle_luainit(L) != LUA_OK) - return 0; /* error running LUA_INIT */ - /* execute arguments -e and -l */ - if (!runargs(L, argv, (script > 0) ? script : argc)) return 0; - /* execute main script (if there is one) */ - if (script && handle_script(L, argv, script) != LUA_OK) return 0; - if (args[has_i]) /* -i option? */ - dotty(L); - else if (script == 0 && !args[has_e] && !args[has_v]) { /* no arguments? */ - if (lua_stdin_is_tty()) { + luaL_openlibs(L); /* open standard libraries */ + createargtable(L, argv, argc, script); /* create table 'arg' */ + if (!(args & has_E)) { /* no option '-E'? */ + if (handle_luainit(L) != LUA_OK) /* run LUA_INIT */ + return 0; /* error running LUA_INIT */ + } + if (!runargs(L, argv, script)) /* execute arguments -e and -l */ + return 0; /* something failed */ + if (script < argc && /* execute main script (if there is one) */ + handle_script(L, argv + script) != LUA_OK) + return 0; + if (args & has_i) /* -i option? */ + doREPL(L); /* do read-eval-print loop */ + else if (script == argc && !(args & (has_e | has_v))) { /* no arguments? */ + if (lua_stdin_is_tty()) { /* running in interactive mode? */ print_version(); - dotty(L); + doREPL(L); /* do read-eval-print loop */ } else dofile(L, NULL); /* executes stdin as a file */ } @@ -484,13 +600,12 @@ int main (int argc, char **argv) { l_message(argv[0], "cannot create state: not enough memory"); return EXIT_FAILURE; } - /* call 'pmain' in protected mode */ - lua_pushcfunction(L, &pmain); + lua_pushcfunction(L, &pmain); /* to call 'pmain' in protected mode */ lua_pushinteger(L, argc); /* 1st argument */ lua_pushlightuserdata(L, argv); /* 2nd argument */ - status = lua_pcall(L, 2, 1, 0); + status = lua_pcall(L, 2, 1, 0); /* do the call */ result = lua_toboolean(L, -1); /* get result */ - finalreport(L, status); + report(L, status); lua_close(L); return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/depends/lua/src/luac.c b/depends/lua/src/luac.c index 7409706ec7..549ad39500 100644 --- a/depends/lua/src/luac.c +++ b/depends/lua/src/luac.c @@ -1,17 +1,20 @@ /* -** $Id: luac.c,v 1.69 2011/11/29 17:46:33 lhf Exp $ -** Lua compiler (saves bytecodes to files; also list bytecodes) +** $Id: luac.c,v 1.76 2018/06/19 01:32:02 lhf Exp $ +** Lua compiler (saves bytecodes to files; also lists bytecodes) ** See Copyright Notice in lua.h */ +#define luac_c +#define LUA_CORE + +#include "lprefix.h" + +#include #include #include #include #include -#define luac_c -#define LUA_CORE - #include "lua.h" #include "lauxlib.h" @@ -47,14 +50,14 @@ static void cannot(const char* what) static void usage(const char* message) { if (*message=='-') - fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message); + fprintf(stderr,"%s: unrecognized option '%s'\n",progname,message); else fprintf(stderr,"%s: %s\n",progname,message); fprintf(stderr, "usage: %s [options] [filenames]\n" "Available options are:\n" " -l list (use -l -l for full listing)\n" - " -o name output to file " LUA_QL("name") " (default is \"%s\")\n" + " -o name output to file 'name' (default is \"%s\")\n" " -p parse only\n" " -s strip debug information\n" " -v show version information\n" @@ -89,7 +92,7 @@ static int doargs(int argc, char* argv[]) { output=argv[++i]; if (output==NULL || *output==0 || (*output=='-' && output[1]!=0)) - usage(LUA_QL("-o") " needs argument"); + usage("'-o' needs argument"); if (IS("-")) output=NULL; } else if (IS("-p")) /* parse only */ @@ -203,7 +206,7 @@ int main(int argc, char* argv[]) } /* -** $Id: print.c,v 1.69 2013/07/04 01:03:46 lhf Exp $ +** $Id: luac.c,v 1.76 2018/06/19 01:32:02 lhf Exp $ ** print bytecodes ** See Copyright Notice in lua.h */ @@ -223,7 +226,7 @@ int main(int argc, char* argv[]) static void PrintString(const TString* ts) { const char* s=getstr(ts); - size_t i,n=ts->tsv.len; + size_t i,n=tsslen(ts); printf("%c",'"'); for (i=0; ik[i]; - switch (ttypenv(o)) + switch (ttype(o)) { case LUA_TNIL: printf("nil"); @@ -259,11 +262,19 @@ static void PrintConstant(const Proto* f, int i) case LUA_TBOOLEAN: printf(bvalue(o) ? "true" : "false"); break; - case LUA_TNUMBER: - printf(LUA_NUMBER_FMT,nvalue(o)); + case LUA_TNUMFLT: + { + char buff[100]; + sprintf(buff,LUA_NUMBER_FMT,fltvalue(o)); + printf("%s",buff); + if (buff[strspn(buff,"-0123456789")]=='\0') printf(".0"); + break; + } + case LUA_TNUMINT: + printf(LUA_INTEGER_FMT,ivalue(o)); break; - case LUA_TSTRING: - PrintString(rawtsvalue(o)); + case LUA_TSHRSTR: case LUA_TLNGSTR: + PrintString(tsvalue(o)); break; default: /* cannot happen */ printf("? type=%d",ttype(o)); @@ -337,8 +348,15 @@ static void PrintCode(const Proto* f) case OP_ADD: case OP_SUB: case OP_MUL: - case OP_DIV: + case OP_MOD: case OP_POW: + case OP_DIV: + case OP_IDIV: + case OP_BAND: + case OP_BOR: + case OP_BXOR: + case OP_SHL: + case OP_SHR: case OP_EQ: case OP_LT: case OP_LE: diff --git a/depends/lua/src/lundump.c b/depends/lua/src/lundump.c index 4163cb5d3b..edf9eb8d00 100644 --- a/depends/lua/src/lundump.c +++ b/depends/lua/src/lundump.c @@ -1,14 +1,17 @@ /* -** $Id: lundump.c,v 2.22.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lundump.c,v 2.44.1.1 2017/04/19 17:20:42 roberto Exp $ ** load precompiled Lua chunks ** See Copyright Notice in lua.h */ -#include - #define lundump_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" #include "ldebug.h" @@ -20,239 +23,265 @@ #include "lundump.h" #include "lzio.h" + +#if !defined(luai_verifycode) +#define luai_verifycode(L,b,f) /* empty */ +#endif + + typedef struct { - lua_State* L; - ZIO* Z; - Mbuffer* b; - const char* name; + lua_State *L; + ZIO *Z; + const char *name; } LoadState; -static l_noret error(LoadState* S, const char* why) -{ - luaO_pushfstring(S->L,"%s: %s precompiled chunk",S->name,why); - luaD_throw(S->L,LUA_ERRSYNTAX); + +static l_noret error(LoadState *S, const char *why) { + luaO_pushfstring(S->L, "%s: %s precompiled chunk", S->name, why); + luaD_throw(S->L, LUA_ERRSYNTAX); } -#define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size)) -#define LoadByte(S) (lu_byte)LoadChar(S) -#define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x)) -#define LoadVector(S,b,n,size) LoadMem(S,b,n,size) -#if !defined(luai_verifycode) -#define luai_verifycode(L,b,f) /* empty */ -#endif +/* +** All high-level loads go through LoadVector; you can change it to +** adapt to the endianness of the input +*/ +#define LoadVector(S,b,n) LoadBlock(S,b,(n)*sizeof((b)[0])) -static void LoadBlock(LoadState* S, void* b, size_t size) -{ - if (luaZ_read(S->Z,b,size)!=0) error(S,"truncated"); +static void LoadBlock (LoadState *S, void *b, size_t size) { + if (luaZ_read(S->Z, b, size) != 0) + error(S, "truncated"); } -static int LoadChar(LoadState* S) -{ - char x; - LoadVar(S,x); - return x; + +#define LoadVar(S,x) LoadVector(S,&x,1) + + +static lu_byte LoadByte (LoadState *S) { + lu_byte x; + LoadVar(S, x); + return x; } -static int LoadInt(LoadState* S) -{ - int x; - LoadVar(S,x); - if (x<0) error(S,"corrupted"); - return x; + +static int LoadInt (LoadState *S) { + int x; + LoadVar(S, x); + return x; } -static lua_Number LoadNumber(LoadState* S) -{ - lua_Number x; - LoadVar(S,x); - return x; + +static lua_Number LoadNumber (LoadState *S) { + lua_Number x; + LoadVar(S, x); + return x; } -static TString* LoadString(LoadState* S) -{ - size_t size; - LoadVar(S,size); - if (size==0) - return NULL; - else - { - char* s=luaZ_openspace(S->L,S->b,size); - LoadBlock(S,s,size*sizeof(char)); - return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */ - } + +static lua_Integer LoadInteger (LoadState *S) { + lua_Integer x; + LoadVar(S, x); + return x; } -static void LoadCode(LoadState* S, Proto* f) -{ - int n=LoadInt(S); - f->code=luaM_newvector(S->L,n,Instruction); - f->sizecode=n; - LoadVector(S,f->code,n,sizeof(Instruction)); + +static TString *LoadString (LoadState *S, Proto *p) { + lua_State *L = S->L; + size_t size = LoadByte(S); + TString *ts; + if (size == 0xFF) + LoadVar(S, size); + if (size == 0) + return NULL; + else if (--size <= LUAI_MAXSHORTLEN) { /* short string? */ + char buff[LUAI_MAXSHORTLEN]; + LoadVector(S, buff, size); + ts = luaS_newlstr(L, buff, size); + } + else { /* long string */ + ts = luaS_createlngstrobj(L, size); + setsvalue2s(L, L->top, ts); /* anchor it ('loadVector' can GC) */ + luaD_inctop(L); + LoadVector(S, getstr(ts), size); /* load directly in final place */ + L->top--; /* pop string */ + } + luaC_objbarrier(L, p, ts); + return ts; } -static void LoadFunction(LoadState* S, Proto* f); - -static void LoadConstants(LoadState* S, Proto* f) -{ - int i,n; - n=LoadInt(S); - f->k=luaM_newvector(S->L,n,TValue); - f->sizek=n; - for (i=0; ik[i]); - for (i=0; ik[i]; - int t=LoadChar(S); - switch (t) - { - case LUA_TNIL: - setnilvalue(o); - break; - case LUA_TBOOLEAN: - setbvalue(o,LoadChar(S)); - break; - case LUA_TNUMBER: - setnvalue(o,LoadNumber(S)); - break; - case LUA_TSTRING: - setsvalue2n(S->L,o,LoadString(S)); - break; - default: lua_assert(0); + +static void LoadCode (LoadState *S, Proto *f) { + int n = LoadInt(S); + f->code = luaM_newvector(S->L, n, Instruction); + f->sizecode = n; + LoadVector(S, f->code, n); +} + + +static void LoadFunction(LoadState *S, Proto *f, TString *psource); + + +static void LoadConstants (LoadState *S, Proto *f) { + int i; + int n = LoadInt(S); + f->k = luaM_newvector(S->L, n, TValue); + f->sizek = n; + for (i = 0; i < n; i++) + setnilvalue(&f->k[i]); + for (i = 0; i < n; i++) { + TValue *o = &f->k[i]; + int t = LoadByte(S); + switch (t) { + case LUA_TNIL: + setnilvalue(o); + break; + case LUA_TBOOLEAN: + setbvalue(o, LoadByte(S)); + break; + case LUA_TNUMFLT: + setfltvalue(o, LoadNumber(S)); + break; + case LUA_TNUMINT: + setivalue(o, LoadInteger(S)); + break; + case LUA_TSHRSTR: + case LUA_TLNGSTR: + setsvalue2n(S->L, o, LoadString(S, f)); + break; + default: + lua_assert(0); + } } - } - n=LoadInt(S); - f->p=luaM_newvector(S->L,n,Proto*); - f->sizep=n; - for (i=0; ip[i]=NULL; - for (i=0; ip[i]=luaF_newproto(S->L); - LoadFunction(S,f->p[i]); - } } -static void LoadUpvalues(LoadState* S, Proto* f) -{ - int i,n; - n=LoadInt(S); - f->upvalues=luaM_newvector(S->L,n,Upvaldesc); - f->sizeupvalues=n; - for (i=0; iupvalues[i].name=NULL; - for (i=0; iupvalues[i].instack=LoadByte(S); - f->upvalues[i].idx=LoadByte(S); - } + +static void LoadProtos (LoadState *S, Proto *f) { + int i; + int n = LoadInt(S); + f->p = luaM_newvector(S->L, n, Proto *); + f->sizep = n; + for (i = 0; i < n; i++) + f->p[i] = NULL; + for (i = 0; i < n; i++) { + f->p[i] = luaF_newproto(S->L); + luaC_objbarrier(S->L, f, f->p[i]); + LoadFunction(S, f->p[i], f->source); + } } -static void LoadDebug(LoadState* S, Proto* f) -{ - int i,n; - f->source=LoadString(S); - n=LoadInt(S); - f->lineinfo=luaM_newvector(S->L,n,int); - f->sizelineinfo=n; - LoadVector(S,f->lineinfo,n,sizeof(int)); - n=LoadInt(S); - f->locvars=luaM_newvector(S->L,n,LocVar); - f->sizelocvars=n; - for (i=0; ilocvars[i].varname=NULL; - for (i=0; ilocvars[i].varname=LoadString(S); - f->locvars[i].startpc=LoadInt(S); - f->locvars[i].endpc=LoadInt(S); - } - n=LoadInt(S); - for (i=0; iupvalues[i].name=LoadString(S); + +static void LoadUpvalues (LoadState *S, Proto *f) { + int i, n; + n = LoadInt(S); + f->upvalues = luaM_newvector(S->L, n, Upvaldesc); + f->sizeupvalues = n; + for (i = 0; i < n; i++) + f->upvalues[i].name = NULL; + for (i = 0; i < n; i++) { + f->upvalues[i].instack = LoadByte(S); + f->upvalues[i].idx = LoadByte(S); + } } -static void LoadFunction(LoadState* S, Proto* f) -{ - f->linedefined=LoadInt(S); - f->lastlinedefined=LoadInt(S); - f->numparams=LoadByte(S); - f->is_vararg=LoadByte(S); - f->maxstacksize=LoadByte(S); - LoadCode(S,f); - LoadConstants(S,f); - LoadUpvalues(S,f); - LoadDebug(S,f); + +static void LoadDebug (LoadState *S, Proto *f) { + int i, n; + n = LoadInt(S); + f->lineinfo = luaM_newvector(S->L, n, int); + f->sizelineinfo = n; + LoadVector(S, f->lineinfo, n); + n = LoadInt(S); + f->locvars = luaM_newvector(S->L, n, LocVar); + f->sizelocvars = n; + for (i = 0; i < n; i++) + f->locvars[i].varname = NULL; + for (i = 0; i < n; i++) { + f->locvars[i].varname = LoadString(S, f); + f->locvars[i].startpc = LoadInt(S); + f->locvars[i].endpc = LoadInt(S); + } + n = LoadInt(S); + for (i = 0; i < n; i++) + f->upvalues[i].name = LoadString(S, f); } -/* the code below must be consistent with the code in luaU_header */ -#define N0 LUAC_HEADERSIZE -#define N1 (sizeof(LUA_SIGNATURE)-sizeof(char)) -#define N2 N1+2 -#define N3 N2+6 - -static void LoadHeader(LoadState* S) -{ - lu_byte h[LUAC_HEADERSIZE]; - lu_byte s[LUAC_HEADERSIZE]; - luaU_header(h); - memcpy(s,h,sizeof(char)); /* first char already read */ - LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char)); - if (memcmp(h,s,N0)==0) return; - if (memcmp(h,s,N1)!=0) error(S,"not a"); - if (memcmp(h,s,N2)!=0) error(S,"version mismatch in"); - if (memcmp(h,s,N3)!=0) error(S,"incompatible"); else error(S,"corrupted"); + +static void LoadFunction (LoadState *S, Proto *f, TString *psource) { + f->source = LoadString(S, f); + if (f->source == NULL) /* no source in dump? */ + f->source = psource; /* reuse parent's source */ + f->linedefined = LoadInt(S); + f->lastlinedefined = LoadInt(S); + f->numparams = LoadByte(S); + f->is_vararg = LoadByte(S); + f->maxstacksize = LoadByte(S); + LoadCode(S, f); + LoadConstants(S, f); + LoadUpvalues(S, f); + LoadProtos(S, f); + LoadDebug(S, f); } -/* -** load precompiled chunk -*/ -Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name) -{ - LoadState S; - Closure* cl; - if (*name=='@' || *name=='=') - S.name=name+1; - else if (*name==LUA_SIGNATURE[0]) - S.name="binary string"; - else - S.name=name; - S.L=L; - S.Z=Z; - S.b=buff; - LoadHeader(&S); - cl=luaF_newLclosure(L,1); - setclLvalue(L,L->top,cl); incr_top(L); - cl->l.p=luaF_newproto(L); - LoadFunction(&S,cl->l.p); - if (cl->l.p->sizeupvalues != 1) - { - Proto* p=cl->l.p; - cl=luaF_newLclosure(L,cl->l.p->sizeupvalues); - cl->l.p=p; - setclLvalue(L,L->top-1,cl); - } - luai_verifycode(L,buff,cl->l.p); - return cl; + +static void checkliteral (LoadState *S, const char *s, const char *msg) { + char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */ + size_t len = strlen(s); + LoadVector(S, buff, len); + if (memcmp(s, buff, len) != 0) + error(S, msg); +} + + +static void fchecksize (LoadState *S, size_t size, const char *tname) { + if (LoadByte(S) != size) + error(S, luaO_pushfstring(S->L, "%s size mismatch in", tname)); +} + + +#define checksize(S,t) fchecksize(S,sizeof(t),#t) + +static void checkHeader (LoadState *S) { + checkliteral(S, LUA_SIGNATURE + 1, "not a"); /* 1st char already checked */ + if (LoadByte(S) != LUAC_VERSION) + error(S, "version mismatch in"); + if (LoadByte(S) != LUAC_FORMAT) + error(S, "format mismatch in"); + checkliteral(S, LUAC_DATA, "corrupted"); + checksize(S, int); + checksize(S, size_t); + checksize(S, Instruction); + checksize(S, lua_Integer); + checksize(S, lua_Number); + if (LoadInteger(S) != LUAC_INT) + error(S, "endianness mismatch in"); + if (LoadNumber(S) != LUAC_NUM) + error(S, "float format mismatch in"); } -#define MYINT(s) (s[0]-'0') -#define VERSION MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR) -#define FORMAT 0 /* this is the official format */ /* -* make header for precompiled chunks -* if you change the code below be sure to update LoadHeader and FORMAT above -* and LUAC_HEADERSIZE in lundump.h +** load precompiled chunk */ -void luaU_header (lu_byte* h) -{ - int x=1; - memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-sizeof(char)); - h+=sizeof(LUA_SIGNATURE)-sizeof(char); - *h++=cast_byte(VERSION); - *h++=cast_byte(FORMAT); - *h++=cast_byte(*(char*)&x); /* endianness */ - *h++=cast_byte(sizeof(int)); - *h++=cast_byte(sizeof(size_t)); - *h++=cast_byte(sizeof(Instruction)); - *h++=cast_byte(sizeof(lua_Number)); - *h++=cast_byte(((lua_Number)0.5)==0); /* is lua_Number integral? */ - memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char)); +LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) { + LoadState S; + LClosure *cl; + if (*name == '@' || *name == '=') + S.name = name + 1; + else if (*name == LUA_SIGNATURE[0]) + S.name = "binary string"; + else + S.name = name; + S.L = L; + S.Z = Z; + checkHeader(&S); + cl = luaF_newLclosure(L, LoadByte(&S)); + setclLvalue(L, L->top, cl); + luaD_inctop(L); + cl->p = luaF_newproto(L); + luaC_objbarrier(L, cl, cl->p); + LoadFunction(&S, cl->p, NULL); + lua_assert(cl->nupvalues == cl->p->sizeupvalues); + luai_verifycode(L, buff, cl->p); + return cl; } + diff --git a/depends/lua/src/lutf8lib.c b/depends/lua/src/lutf8lib.c new file mode 100644 index 0000000000..10bd238a71 --- /dev/null +++ b/depends/lua/src/lutf8lib.c @@ -0,0 +1,256 @@ +/* +** $Id: lutf8lib.c,v 1.16.1.1 2017/04/19 17:29:57 roberto Exp $ +** Standard library for UTF-8 manipulation +** See Copyright Notice in lua.h +*/ + +#define lutf8lib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + +#define MAXUNICODE 0x10FFFF + +#define iscont(p) ((*(p) & 0xC0) == 0x80) + + +/* from strlib */ +/* translate a relative string position: negative means back from end */ +static lua_Integer u_posrelat (lua_Integer pos, size_t len) { + if (pos >= 0) return pos; + else if (0u - (size_t)pos > len) return 0; + else return (lua_Integer)len + pos + 1; +} + + +/* +** Decode one UTF-8 sequence, returning NULL if byte sequence is invalid. +*/ +static const char *utf8_decode (const char *o, int *val) { + static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF}; + const unsigned char *s = (const unsigned char *)o; + unsigned int c = s[0]; + unsigned int res = 0; /* final result */ + if (c < 0x80) /* ascii? */ + res = c; + else { + int count = 0; /* to count number of continuation bytes */ + while (c & 0x40) { /* still have continuation bytes? */ + int cc = s[++count]; /* read next byte */ + if ((cc & 0xC0) != 0x80) /* not a continuation byte? */ + return NULL; /* invalid byte sequence */ + res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */ + c <<= 1; /* to test next bit */ + } + res |= ((c & 0x7F) << (count * 5)); /* add first byte */ + if (count > 3 || res > MAXUNICODE || res <= limits[count]) + return NULL; /* invalid byte sequence */ + s += count; /* skip continuation bytes read */ + } + if (val) *val = res; + return (const char *)s + 1; /* +1 to include first byte */ +} + + +/* +** utf8len(s [, i [, j]]) --> number of characters that start in the +** range [i,j], or nil + current position if 's' is not well formed in +** that interval +*/ +static int utflen (lua_State *L) { + int n = 0; + size_t len; + const char *s = luaL_checklstring(L, 1, &len); + lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len); + lua_Integer posj = u_posrelat(luaL_optinteger(L, 3, -1), len); + luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 2, + "initial position out of string"); + luaL_argcheck(L, --posj < (lua_Integer)len, 3, + "final position out of string"); + while (posi <= posj) { + const char *s1 = utf8_decode(s + posi, NULL); + if (s1 == NULL) { /* conversion error? */ + lua_pushnil(L); /* return nil ... */ + lua_pushinteger(L, posi + 1); /* ... and current position */ + return 2; + } + posi = s1 - s; + n++; + } + lua_pushinteger(L, n); + return 1; +} + + +/* +** codepoint(s, [i, [j]]) -> returns codepoints for all characters +** that start in the range [i,j] +*/ +static int codepoint (lua_State *L) { + size_t len; + const char *s = luaL_checklstring(L, 1, &len); + lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len); + lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len); + int n; + const char *se; + luaL_argcheck(L, posi >= 1, 2, "out of range"); + luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of range"); + if (posi > pose) return 0; /* empty interval; return no values */ + if (pose - posi >= INT_MAX) /* (lua_Integer -> int) overflow? */ + return luaL_error(L, "string slice too long"); + n = (int)(pose - posi) + 1; + luaL_checkstack(L, n, "string slice too long"); + n = 0; + se = s + pose; + for (s += posi - 1; s < se;) { + int code; + s = utf8_decode(s, &code); + if (s == NULL) + return luaL_error(L, "invalid UTF-8 code"); + lua_pushinteger(L, code); + n++; + } + return n; +} + + +static void pushutfchar (lua_State *L, int arg) { + lua_Integer code = luaL_checkinteger(L, arg); + luaL_argcheck(L, 0 <= code && code <= MAXUNICODE, arg, "value out of range"); + lua_pushfstring(L, "%U", (long)code); +} + + +/* +** utfchar(n1, n2, ...) -> char(n1)..char(n2)... +*/ +static int utfchar (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + if (n == 1) /* optimize common case of single char */ + pushutfchar(L, 1); + else { + int i; + luaL_Buffer b; + luaL_buffinit(L, &b); + for (i = 1; i <= n; i++) { + pushutfchar(L, i); + luaL_addvalue(&b); + } + luaL_pushresult(&b); + } + return 1; +} + + +/* +** offset(s, n, [i]) -> index where n-th character counting from +** position 'i' starts; 0 means character at 'i'. +*/ +static int byteoffset (lua_State *L) { + size_t len; + const char *s = luaL_checklstring(L, 1, &len); + lua_Integer n = luaL_checkinteger(L, 2); + lua_Integer posi = (n >= 0) ? 1 : len + 1; + posi = u_posrelat(luaL_optinteger(L, 3, posi), len); + luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3, + "position out of range"); + if (n == 0) { + /* find beginning of current byte sequence */ + while (posi > 0 && iscont(s + posi)) posi--; + } + else { + if (iscont(s + posi)) + return luaL_error(L, "initial position is a continuation byte"); + if (n < 0) { + while (n < 0 && posi > 0) { /* move back */ + do { /* find beginning of previous character */ + posi--; + } while (posi > 0 && iscont(s + posi)); + n++; + } + } + else { + n--; /* do not move for 1st character */ + while (n > 0 && posi < (lua_Integer)len) { + do { /* find beginning of next character */ + posi++; + } while (iscont(s + posi)); /* (cannot pass final '\0') */ + n--; + } + } + } + if (n == 0) /* did it find given character? */ + lua_pushinteger(L, posi + 1); + else /* no such character */ + lua_pushnil(L); + return 1; +} + + +static int iter_aux (lua_State *L) { + size_t len; + const char *s = luaL_checklstring(L, 1, &len); + lua_Integer n = lua_tointeger(L, 2) - 1; + if (n < 0) /* first iteration? */ + n = 0; /* start from here */ + else if (n < (lua_Integer)len) { + n++; /* skip current byte */ + while (iscont(s + n)) n++; /* and its continuations */ + } + if (n >= (lua_Integer)len) + return 0; /* no more codepoints */ + else { + int code; + const char *next = utf8_decode(s + n, &code); + if (next == NULL || iscont(next)) + return luaL_error(L, "invalid UTF-8 code"); + lua_pushinteger(L, n + 1); + lua_pushinteger(L, code); + return 2; + } +} + + +static int iter_codes (lua_State *L) { + luaL_checkstring(L, 1); + lua_pushcfunction(L, iter_aux); + lua_pushvalue(L, 1); + lua_pushinteger(L, 0); + return 3; +} + + +/* pattern to match a single UTF-8 character */ +#define UTF8PATT "[\0-\x7F\xC2-\xF4][\x80-\xBF]*" + + +static const luaL_Reg funcs[] = { + {"offset", byteoffset}, + {"codepoint", codepoint}, + {"char", utfchar}, + {"len", utflen}, + {"codes", iter_codes}, + /* placeholders */ + {"charpattern", NULL}, + {NULL, NULL} +}; + + +LUAMOD_API int luaopen_utf8 (lua_State *L) { + luaL_newlib(L, funcs); + lua_pushlstring(L, UTF8PATT, sizeof(UTF8PATT)/sizeof(char) - 1); + lua_setfield(L, -2, "charpattern"); + return 1; +} + diff --git a/depends/lua/src/lvm.c b/depends/lua/src/lvm.c index 141b9fd19c..cc43d8714d 100644 --- a/depends/lua/src/lvm.c +++ b/depends/lua/src/lvm.c @@ -1,17 +1,21 @@ /* -** $Id: lvm.c,v 2.155.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lvm.c,v 2.268.1.1 2017/04/19 17:39:34 roberto Exp $ ** Lua virtual machine ** See Copyright Notice in lua.h */ +#define lvm_c +#define LUA_CORE + +#include "lprefix.h" +#include +#include +#include #include #include #include -#define lvm_c -#define LUA_CORE - #include "lua.h" #include "ldebug.h" @@ -27,304 +31,479 @@ #include "lvm.h" - /* limit for table tag-method chains (to avoid loops) */ -#define MAXTAGLOOP 100 +#define MAXTAGLOOP 2000 -const TValue *luaV_tonumber (const TValue *obj, TValue *n) { - lua_Number num; - if (ttisnumber(obj)) return obj; - if (ttisstring(obj) && luaO_str2d(svalue(obj), tsvalue(obj)->len, &num)) { - setnvalue(n, num); - return n; - } - else - return NULL; -} +/* +** 'l_intfitsf' checks whether a given integer can be converted to a +** float without rounding. Used in comparisons. Left undefined if +** all integers fit in a float precisely. +*/ +#if !defined(l_intfitsf) -int luaV_tostring (lua_State *L, StkId obj) { - if (!ttisnumber(obj)) - return 0; - else { - char s[LUAI_MAXNUMBER2STR]; - lua_Number n = nvalue(obj); - int l = lua_number2str(s, n); - setsvalue2s(L, obj, luaS_newlstr(L, s, l)); +/* number of bits in the mantissa of a float */ +#define NBM (l_mathlim(MANT_DIG)) + +/* +** Check whether some integers may not fit in a float, that is, whether +** (maxinteger >> NBM) > 0 (that implies (1 << NBM) <= maxinteger). +** (The shifts are done in parts to avoid shifting by more than the size +** of an integer. In a worst case, NBM == 113 for long double and +** sizeof(integer) == 32.) +*/ +#if ((((LUA_MAXINTEGER >> (NBM / 4)) >> (NBM / 4)) >> (NBM / 4)) \ + >> (NBM - (3 * (NBM / 4)))) > 0 + +#define l_intfitsf(i) \ + (-((lua_Integer)1 << NBM) <= (i) && (i) <= ((lua_Integer)1 << NBM)) + +#endif + +#endif + + + +/* +** Try to convert a value to a float. The float case is already handled +** by the macro 'tonumber'. +*/ +int luaV_tonumber_ (const TValue *obj, lua_Number *n) { + TValue v; + if (ttisinteger(obj)) { + *n = cast_num(ivalue(obj)); + return 1; + } + else if (cvt2num(obj) && /* string convertible to number? */ + luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) { + *n = nvalue(&v); /* convert result of 'luaO_str2num' to a float */ return 1; } + else + return 0; /* conversion failed */ } -static void traceexec (lua_State *L) { - CallInfo *ci = L->ci; - lu_byte mask = L->hookmask; - int counthook = ((mask & LUA_MASKCOUNT) && L->hookcount == 0); - if (counthook) - resethookcount(L); /* reset count */ - if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */ - ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ - return; /* do not call hook again (VM yielded, so it did not move) */ +/* +** try to convert a value to an integer, rounding according to 'mode': +** mode == 0: accepts only integral values +** mode == 1: takes the floor of the number +** mode == 2: takes the ceil of the number +*/ +int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode) { + TValue v; + again: + if (ttisfloat(obj)) { + lua_Number n = fltvalue(obj); + lua_Number f = l_floor(n); + if (n != f) { /* not an integral value? */ + if (mode == 0) return 0; /* fails if mode demands integral value */ + else if (mode > 1) /* needs ceil? */ + f += 1; /* convert floor to ceil (remember: n != f) */ + } + return lua_numbertointeger(f, p); } - if (counthook) - luaD_hook(L, LUA_HOOKCOUNT, -1); /* call count hook */ - if (mask & LUA_MASKLINE) { - Proto *p = ci_func(ci)->p; - int npc = pcRel(ci->u.l.savedpc, p); - int newline = getfuncline(p, npc); - if (npc == 0 || /* call linehook when enter a new function, */ - ci->u.l.savedpc <= L->oldpc || /* when jump back (loop), or when */ - newline != getfuncline(p, pcRel(L->oldpc, p))) /* enter a new line */ - luaD_hook(L, LUA_HOOKLINE, newline); /* call line hook */ + else if (ttisinteger(obj)) { + *p = ivalue(obj); + return 1; } - L->oldpc = ci->u.l.savedpc; - if (L->status == LUA_YIELD) { /* did hook yield? */ - if (counthook) - L->hookcount = 1; /* undo decrement to zero */ - ci->u.l.savedpc--; /* undo increment (resume will increment it again) */ - ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ - ci->func = L->top - 1; /* protect stack below results */ - luaD_throw(L, LUA_YIELD); + else if (cvt2num(obj) && + luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) { + obj = &v; + goto again; /* convert result from 'luaO_str2num' to an integer */ } + return 0; /* conversion failed */ } -static void callTM (lua_State *L, const TValue *f, const TValue *p1, - const TValue *p2, TValue *p3, int hasres) { - ptrdiff_t result = savestack(L, p3); - setobj2s(L, L->top++, f); /* push function */ - setobj2s(L, L->top++, p1); /* 1st argument */ - setobj2s(L, L->top++, p2); /* 2nd argument */ - if (!hasres) /* no result? 'p3' is third argument */ - setobj2s(L, L->top++, p3); /* 3rd argument */ - /* metamethod may yield only when called from Lua code */ - luaD_call(L, L->top - (4 - hasres), hasres, isLua(L->ci)); - if (hasres) { /* if has result, move it to its place */ - p3 = restorestack(L, result); - setobjs2s(L, p3, --L->top); +/* +** Try to convert a 'for' limit to an integer, preserving the +** semantics of the loop. +** (The following explanation assumes a non-negative step; it is valid +** for negative steps mutatis mutandis.) +** If the limit can be converted to an integer, rounding down, that is +** it. +** Otherwise, check whether the limit can be converted to a number. If +** the number is too large, it is OK to set the limit as LUA_MAXINTEGER, +** which means no limit. If the number is too negative, the loop +** should not run, because any initial integer value is larger than the +** limit. So, it sets the limit to LUA_MININTEGER. 'stopnow' corrects +** the extreme case when the initial value is LUA_MININTEGER, in which +** case the LUA_MININTEGER limit would still run the loop once. +*/ +static int forlimit (const TValue *obj, lua_Integer *p, lua_Integer step, + int *stopnow) { + *stopnow = 0; /* usually, let loops run */ + if (!luaV_tointeger(obj, p, (step < 0 ? 2 : 1))) { /* not fit in integer? */ + lua_Number n; /* try to convert to float */ + if (!tonumber(obj, &n)) /* cannot convert to float? */ + return 0; /* not a number */ + if (luai_numlt(0, n)) { /* if true, float is larger than max integer */ + *p = LUA_MAXINTEGER; + if (step < 0) *stopnow = 1; + } + else { /* float is smaller than min integer */ + *p = LUA_MININTEGER; + if (step >= 0) *stopnow = 1; + } } + return 1; } -void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) { - int loop; +/* +** Finish the table access 'val = t[key]'. +** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to +** t[k] entry (which must be nil). +*/ +void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val, + const TValue *slot) { + int loop; /* counter to avoid infinite loops */ + const TValue *tm; /* metamethod */ for (loop = 0; loop < MAXTAGLOOP; loop++) { - const TValue *tm; - if (ttistable(t)) { /* `t' is a table? */ - Table *h = hvalue(t); - const TValue *res = luaH_get(h, key); /* do a primitive get */ - if (!ttisnil(res) || /* result is not nil? */ - (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */ - setobj2s(L, val, res); + if (slot == NULL) { /* 't' is not a table? */ + lua_assert(!ttistable(t)); + tm = luaT_gettmbyobj(L, t, TM_INDEX); + if (ttisnil(tm)) + luaG_typeerror(L, t, "index"); /* no metamethod */ + /* else will try the metamethod */ + } + else { /* 't' is a table */ + lua_assert(ttisnil(slot)); + tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */ + if (tm == NULL) { /* no metamethod? */ + setnilvalue(val); /* result is nil */ return; } - /* else will try the tag method */ + /* else will try the metamethod */ } - else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))) - luaG_typeerror(L, t, "index"); - if (ttisfunction(tm)) { - callTM(L, tm, t, key, val, 1); + if (ttisfunction(tm)) { /* is metamethod a function? */ + luaT_callTM(L, tm, t, key, val, 1); /* call it */ + return; + } + t = tm; /* else try to access 'tm[key]' */ + if (luaV_fastget(L,t,key,slot,luaH_get)) { /* fast track? */ + setobj2s(L, val, slot); /* done */ return; } - t = tm; /* else repeat with 'tm' */ + /* else repeat (tail call 'luaV_finishget') */ } - luaG_runerror(L, "loop in gettable"); + luaG_runerror(L, "'__index' chain too long; possible loop"); } -void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) { - int loop; +/* +** Finish a table assignment 't[key] = val'. +** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points +** to the entry 't[key]', or to 'luaO_nilobject' if there is no such +** entry. (The value at 'slot' must be nil, otherwise 'luaV_fastset' +** would have done the job.) +*/ +void luaV_finishset (lua_State *L, const TValue *t, TValue *key, + StkId val, const TValue *slot) { + int loop; /* counter to avoid infinite loops */ for (loop = 0; loop < MAXTAGLOOP; loop++) { - const TValue *tm; - if (ttistable(t)) { /* `t' is a table? */ - Table *h = hvalue(t); - TValue *oldval = cast(TValue *, luaH_get(h, key)); - /* if previous value is not nil, there must be a previous entry - in the table; moreover, a metamethod has no relevance */ - if (!ttisnil(oldval) || - /* previous value is nil; must check the metamethod */ - ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL && - /* no metamethod; is there a previous entry in the table? */ - (oldval != luaO_nilobject || - /* no previous entry; must create one. (The next test is - always true; we only need the assignment.) */ - (oldval = luaH_newkey(L, h, key), 1)))) { + const TValue *tm; /* '__newindex' metamethod */ + if (slot != NULL) { /* is 't' a table? */ + Table *h = hvalue(t); /* save 't' table */ + lua_assert(ttisnil(slot)); /* old value must be nil */ + tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */ + if (tm == NULL) { /* no metamethod? */ + if (slot == luaO_nilobject) /* no previous entry? */ + slot = luaH_newkey(L, h, key); /* create one */ /* no metamethod and (now) there is an entry with given key */ - setobj2t(L, oldval, val); /* assign new value to that entry */ + setobj2t(L, cast(TValue *, slot), val); /* set its new value */ invalidateTMcache(h); - luaC_barrierback(L, obj2gco(h), val); + luaC_barrierback(L, h, val); return; } /* else will try the metamethod */ } - else /* not a table; check metamethod */ + else { /* not a table; check metamethod */ if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))) luaG_typeerror(L, t, "index"); - /* there is a metamethod */ + } + /* try the metamethod */ if (ttisfunction(tm)) { - callTM(L, tm, t, key, val, 0); + luaT_callTM(L, tm, t, key, val, 0); return; } - t = tm; /* else repeat with 'tm' */ + t = tm; /* else repeat assignment over 'tm' */ + if (luaV_fastset(L, t, key, slot, luaH_get, val)) + return; /* done */ + /* else loop */ } - luaG_runerror(L, "loop in settable"); + luaG_runerror(L, "'__newindex' chain too long; possible loop"); } -static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2, - StkId res, TMS event) { - const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ - if (ttisnil(tm)) - tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ - if (ttisnil(tm)) return 0; - callTM(L, tm, p1, p2, res, 1); - return 1; +/* +** Compare two strings 'ls' x 'rs', returning an integer smaller-equal- +** -larger than zero if 'ls' is smaller-equal-larger than 'rs'. +** The code is a little tricky because it allows '\0' in the strings +** and it uses 'strcoll' (to respect locales) for each segments +** of the strings. +*/ +static int l_strcmp (const TString *ls, const TString *rs) { + const char *l = getstr(ls); + size_t ll = tsslen(ls); + const char *r = getstr(rs); + size_t lr = tsslen(rs); + for (;;) { /* for each segment */ + int temp = strcoll(l, r); + if (temp != 0) /* not equal? */ + return temp; /* done */ + else { /* strings are equal up to a '\0' */ + size_t len = strlen(l); /* index of first '\0' in both strings */ + if (len == lr) /* 'rs' is finished? */ + return (len == ll) ? 0 : 1; /* check 'ls' */ + else if (len == ll) /* 'ls' is finished? */ + return -1; /* 'ls' is smaller than 'rs' ('rs' is not finished) */ + /* both strings longer than 'len'; go on comparing after the '\0' */ + len++; + l += len; ll -= len; r += len; lr -= len; + } + } } -static const TValue *get_equalTM (lua_State *L, Table *mt1, Table *mt2, - TMS event) { - const TValue *tm1 = fasttm(L, mt1, event); - const TValue *tm2; - if (tm1 == NULL) return NULL; /* no metamethod */ - if (mt1 == mt2) return tm1; /* same metatables => same metamethods */ - tm2 = fasttm(L, mt2, event); - if (tm2 == NULL) return NULL; /* no metamethod */ - if (luaV_rawequalobj(tm1, tm2)) /* same metamethods? */ - return tm1; - return NULL; +/* +** Check whether integer 'i' is less than float 'f'. If 'i' has an +** exact representation as a float ('l_intfitsf'), compare numbers as +** floats. Otherwise, if 'f' is outside the range for integers, result +** is trivial. Otherwise, compare them as integers. (When 'i' has no +** float representation, either 'f' is "far away" from 'i' or 'f' has +** no precision left for a fractional part; either way, how 'f' is +** truncated is irrelevant.) When 'f' is NaN, comparisons must result +** in false. +*/ +static int LTintfloat (lua_Integer i, lua_Number f) { +#if defined(l_intfitsf) + if (!l_intfitsf(i)) { + if (f >= -cast_num(LUA_MININTEGER)) /* -minint == maxint + 1 */ + return 1; /* f >= maxint + 1 > i */ + else if (f > cast_num(LUA_MININTEGER)) /* minint < f <= maxint ? */ + return (i < cast(lua_Integer, f)); /* compare them as integers */ + else /* f <= minint <= i (or 'f' is NaN) --> not(i < f) */ + return 0; + } +#endif + return luai_numlt(cast_num(i), f); /* compare them as floats */ } -static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2, - TMS event) { - if (!call_binTM(L, p1, p2, L->top, event)) - return -1; /* no metamethod */ - else - return !l_isfalse(L->top); +/* +** Check whether integer 'i' is less than or equal to float 'f'. +** See comments on previous function. +*/ +static int LEintfloat (lua_Integer i, lua_Number f) { +#if defined(l_intfitsf) + if (!l_intfitsf(i)) { + if (f >= -cast_num(LUA_MININTEGER)) /* -minint == maxint + 1 */ + return 1; /* f >= maxint + 1 > i */ + else if (f >= cast_num(LUA_MININTEGER)) /* minint <= f <= maxint ? */ + return (i <= cast(lua_Integer, f)); /* compare them as integers */ + else /* f < minint <= i (or 'f' is NaN) --> not(i <= f) */ + return 0; + } +#endif + return luai_numle(cast_num(i), f); /* compare them as floats */ } -static int l_strcmp (const TString *ls, const TString *rs) { - const char *l = getstr(ls); - size_t ll = ls->tsv.len; - const char *r = getstr(rs); - size_t lr = rs->tsv.len; - for (;;) { - int temp = strcoll(l, r); - if (temp != 0) return temp; - else { /* strings are equal up to a `\0' */ - size_t len = strlen(l); /* index of first `\0' in both strings */ - if (len == lr) /* r is finished? */ - return (len == ll) ? 0 : 1; - else if (len == ll) /* l is finished? */ - return -1; /* l is smaller than r (because r is not finished) */ - /* both strings longer than `len'; go on comparing (after the `\0') */ - len++; - l += len; ll -= len; r += len; lr -= len; - } +/* +** Return 'l < r', for numbers. +*/ +static int LTnum (const TValue *l, const TValue *r) { + if (ttisinteger(l)) { + lua_Integer li = ivalue(l); + if (ttisinteger(r)) + return li < ivalue(r); /* both are integers */ + else /* 'l' is int and 'r' is float */ + return LTintfloat(li, fltvalue(r)); /* l < r ? */ + } + else { + lua_Number lf = fltvalue(l); /* 'l' must be float */ + if (ttisfloat(r)) + return luai_numlt(lf, fltvalue(r)); /* both are float */ + else if (luai_numisnan(lf)) /* 'r' is int and 'l' is float */ + return 0; /* NaN < i is always false */ + else /* without NaN, (l < r) <--> not(r <= l) */ + return !LEintfloat(ivalue(r), lf); /* not (r <= l) ? */ } } +/* +** Return 'l <= r', for numbers. +*/ +static int LEnum (const TValue *l, const TValue *r) { + if (ttisinteger(l)) { + lua_Integer li = ivalue(l); + if (ttisinteger(r)) + return li <= ivalue(r); /* both are integers */ + else /* 'l' is int and 'r' is float */ + return LEintfloat(li, fltvalue(r)); /* l <= r ? */ + } + else { + lua_Number lf = fltvalue(l); /* 'l' must be float */ + if (ttisfloat(r)) + return luai_numle(lf, fltvalue(r)); /* both are float */ + else if (luai_numisnan(lf)) /* 'r' is int and 'l' is float */ + return 0; /* NaN <= i is always false */ + else /* without NaN, (l <= r) <--> not(r < l) */ + return !LTintfloat(ivalue(r), lf); /* not (r < l) ? */ + } +} + + +/* +** Main operation less than; return 'l < r'. +*/ int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) { int res; - if (ttisnumber(l) && ttisnumber(r)) - return luai_numlt(L, nvalue(l), nvalue(r)); - else if (ttisstring(l) && ttisstring(r)) - return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0; - else if ((res = call_orderTM(L, l, r, TM_LT)) < 0) - luaG_ordererror(L, l, r); + if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */ + return LTnum(l, r); + else if (ttisstring(l) && ttisstring(r)) /* both are strings? */ + return l_strcmp(tsvalue(l), tsvalue(r)) < 0; + else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0) /* no metamethod? */ + luaG_ordererror(L, l, r); /* error */ return res; } +/* +** Main operation less than or equal to; return 'l <= r'. If it needs +** a metamethod and there is no '__le', try '__lt', based on +** l <= r iff !(r < l) (assuming a total order). If the metamethod +** yields during this substitution, the continuation has to know +** about it (to negate the result of r= 0) /* first try `le' */ + if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */ + return LEnum(l, r); + else if (ttisstring(l) && ttisstring(r)) /* both are strings? */ + return l_strcmp(tsvalue(l), tsvalue(r)) <= 0; + else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0) /* try 'le' */ return res; - else if ((res = call_orderTM(L, r, l, TM_LT)) < 0) /* else try `lt' */ - luaG_ordererror(L, l, r); - return !res; + else { /* try 'lt': */ + L->ci->callstatus |= CIST_LEQ; /* mark it is doing 'lt' for 'le' */ + res = luaT_callorderTM(L, r, l, TM_LT); + L->ci->callstatus ^= CIST_LEQ; /* clear mark */ + if (res < 0) + luaG_ordererror(L, l, r); + return !res; /* result is negated */ + } } /* -** equality of Lua values. L == NULL means raw equality (no metamethods) +** Main operation for equality of Lua values; return 't1 == t2'. +** L == NULL means raw equality (no metamethods) */ -int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2) { +int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) { const TValue *tm; - lua_assert(ttisequal(t1, t2)); + if (ttype(t1) != ttype(t2)) { /* not the same variant? */ + if (ttnov(t1) != ttnov(t2) || ttnov(t1) != LUA_TNUMBER) + return 0; /* only numbers can be equal with different variants */ + else { /* two numbers with different variants */ + lua_Integer i1, i2; /* compare them as integers */ + return (tointeger(t1, &i1) && tointeger(t2, &i2) && i1 == i2); + } + } + /* values have same type and same variant */ switch (ttype(t1)) { case LUA_TNIL: return 1; - case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2)); + case LUA_TNUMINT: return (ivalue(t1) == ivalue(t2)); + case LUA_TNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */ case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); case LUA_TLCF: return fvalue(t1) == fvalue(t2); - case LUA_TSHRSTR: return eqshrstr(rawtsvalue(t1), rawtsvalue(t2)); - case LUA_TLNGSTR: return luaS_eqlngstr(rawtsvalue(t1), rawtsvalue(t2)); + case LUA_TSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); + case LUA_TLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); case LUA_TUSERDATA: { if (uvalue(t1) == uvalue(t2)) return 1; else if (L == NULL) return 0; - tm = get_equalTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable, TM_EQ); + tm = fasttm(L, uvalue(t1)->metatable, TM_EQ); + if (tm == NULL) + tm = fasttm(L, uvalue(t2)->metatable, TM_EQ); break; /* will try TM */ } case LUA_TTABLE: { if (hvalue(t1) == hvalue(t2)) return 1; else if (L == NULL) return 0; - tm = get_equalTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ); + tm = fasttm(L, hvalue(t1)->metatable, TM_EQ); + if (tm == NULL) + tm = fasttm(L, hvalue(t2)->metatable, TM_EQ); break; /* will try TM */ } default: - lua_assert(iscollectable(t1)); return gcvalue(t1) == gcvalue(t2); } - if (tm == NULL) return 0; /* no TM? */ - callTM(L, tm, t1, t2, L->top, 1); /* call TM */ + if (tm == NULL) /* no TM? */ + return 0; /* objects are different */ + luaT_callTM(L, tm, t1, t2, L->top, 1); /* call TM */ return !l_isfalse(L->top); } +/* macro used by 'luaV_concat' to ensure that element at 'o' is a string */ +#define tostring(L,o) \ + (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) + +#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) + +/* copy strings in stack from top - n up to top - 1 to buffer */ +static void copy2buff (StkId top, int n, char *buff) { + size_t tl = 0; /* size already copied */ + do { + size_t l = vslen(top - n); /* length of string being copied */ + memcpy(buff + tl, svalue(top - n), l * sizeof(char)); + tl += l; + } while (--n > 0); +} + + +/* +** Main operation for concatenation: concat 'total' values in the stack, +** from 'L->top - total' up to 'L->top - 1'. +*/ void luaV_concat (lua_State *L, int total) { lua_assert(total >= 2); do { StkId top = L->top; int n = 2; /* number of elements handled in this pass (at least 2) */ - if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) { - if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT)) - luaG_concaterror(L, top-2, top-1); - } - else if (tsvalue(top-1)->len == 0) /* second operand is empty? */ - (void)tostring(L, top - 2); /* result is first operand */ - else if (ttisstring(top-2) && tsvalue(top-2)->len == 0) { + if (!(ttisstring(top-2) || cvt2str(top-2)) || !tostring(L, top-1)) + luaT_trybinTM(L, top-2, top-1, top-2, TM_CONCAT); + else if (isemptystr(top - 1)) /* second operand is empty? */ + cast_void(tostring(L, top - 2)); /* result is first operand */ + else if (isemptystr(top - 2)) { /* first operand is an empty string? */ setobjs2s(L, top - 2, top - 1); /* result is second op. */ } else { /* at least two non-empty string values; get as many as possible */ - size_t tl = tsvalue(top-1)->len; - char *buffer; - int i; - /* collect total length */ - for (i = 1; i < total && tostring(L, top-i-1); i++) { - size_t l = tsvalue(top-i-1)->len; - if (l >= (MAX_SIZET/sizeof(char)) - tl) + size_t tl = vslen(top - 1); + TString *ts; + /* collect total length and number of strings */ + for (n = 1; n < total && tostring(L, top - n - 1); n++) { + size_t l = vslen(top - n - 1); + if (l >= (MAX_SIZE/sizeof(char)) - tl) luaG_runerror(L, "string length overflow"); tl += l; } - buffer = luaZ_openspace(L, &G(L)->buff, tl); - tl = 0; - n = i; - do { /* concat all strings */ - size_t l = tsvalue(top-i)->len; - memcpy(buffer+tl, svalue(top-i), l * sizeof(char)); - tl += l; - } while (--i > 0); - setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl)); + if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */ + char buff[LUAI_MAXSHORTLEN]; + copy2buff(top, n, buff); /* copy strings to buffer */ + ts = luaS_newlstr(L, buff, tl); + } + else { /* long string; copy strings directly to final result */ + ts = luaS_createlngstrobj(L, tl); + copy2buff(top, n, getstr(ts)); + } + setsvalue2s(L, top - n, ts); /* create result */ } total -= n-1; /* got 'n' strings to create 1 new */ L->top -= n-1; /* popped 'n' strings and pushed one */ @@ -332,18 +511,25 @@ void luaV_concat (lua_State *L, int total) { } +/* +** Main operation 'ra' = #rb'. +*/ void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { const TValue *tm; - switch (ttypenv(rb)) { + switch (ttype(rb)) { case LUA_TTABLE: { Table *h = hvalue(rb); tm = fasttm(L, h->metatable, TM_LEN); if (tm) break; /* metamethod? break switch to call it */ - setnvalue(ra, cast_num(luaH_getn(h))); /* else primitive len */ + setivalue(ra, luaH_getn(h)); /* else primitive len */ return; } - case LUA_TSTRING: { - setnvalue(ra, cast_num(tsvalue(rb)->len)); + case LUA_TSHRSTR: { + setivalue(ra, tsvalue(rb)->shrlen); + return; + } + case LUA_TLNGSTR: { + setivalue(ra, tsvalue(rb)->u.lnglen); return; } default: { /* try metamethod */ @@ -353,21 +539,66 @@ void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { break; } } - callTM(L, tm, rb, rb, ra, 1); + luaT_callTM(L, tm, rb, rb, ra, 1); +} + + +/* +** Integer division; return 'm // n', that is, floor(m/n). +** C division truncates its result (rounds towards zero). +** 'floor(q) == trunc(q)' when 'q >= 0' or when 'q' is integer, +** otherwise 'floor(q) == trunc(q) - 1'. +*/ +lua_Integer luaV_div (lua_State *L, lua_Integer m, lua_Integer n) { + if (l_castS2U(n) + 1u <= 1u) { /* special cases: -1 or 0 */ + if (n == 0) + luaG_runerror(L, "attempt to divide by zero"); + return intop(-, 0, m); /* n==-1; avoid overflow with 0x80000...//-1 */ + } + else { + lua_Integer q = m / n; /* perform C division */ + if ((m ^ n) < 0 && m % n != 0) /* 'm/n' would be negative non-integer? */ + q -= 1; /* correct result for different rounding */ + return q; + } +} + + +/* +** Integer modulus; return 'm % n'. (Assume that C '%' with +** negative operands follows C99 behavior. See previous comment +** about luaV_div.) +*/ +lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) { + if (l_castS2U(n) + 1u <= 1u) { /* special cases: -1 or 0 */ + if (n == 0) + luaG_runerror(L, "attempt to perform 'n%%0'"); + return 0; /* m % -1 == 0; avoid overflow with 0x80000...%-1 */ + } + else { + lua_Integer r = m % n; + if (r != 0 && (m ^ n) < 0) /* 'm/n' would be non-integer negative? */ + r += n; /* correct result for different rounding */ + return r; + } } -void luaV_arith (lua_State *L, StkId ra, const TValue *rb, - const TValue *rc, TMS op) { - TValue tempb, tempc; - const TValue *b, *c; - if ((b = luaV_tonumber(rb, &tempb)) != NULL && - (c = luaV_tonumber(rc, &tempc)) != NULL) { - lua_Number res = luaO_arith(op - TM_ADD + LUA_OPADD, nvalue(b), nvalue(c)); - setnvalue(ra, res); +/* number of bits in an integer */ +#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) + +/* +** Shift left operation. (Shift right just negates 'y'.) +*/ +lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) { + if (y < 0) { /* shift right? */ + if (y <= -NBITS) return 0; + else return intop(>>, x, -y); + } + else { /* shift left */ + if (y >= NBITS) return 0; + else return intop(<<, x, y); } - else if (!call_binTM(L, rb, rc, ra, op)) - luaG_aritherror(L, rb, rc); } @@ -376,15 +607,15 @@ void luaV_arith (lua_State *L, StkId ra, const TValue *rb, ** whether there is a cached closure with the same upvalues needed by ** new closure to be created. */ -static Closure *getcached (Proto *p, UpVal **encup, StkId base) { - Closure *c = p->cache; +static LClosure *getcached (Proto *p, UpVal **encup, StkId base) { + LClosure *c = p->cache; if (c != NULL) { /* is there a cached closure? */ int nup = p->sizeupvalues; Upvaldesc *uv = p->upvalues; int i; for (i = 0; i < nup; i++) { /* check whether it has right upvalues */ TValue *v = uv[i].instack ? base + uv[i].idx : encup[uv[i].idx]->v; - if (c->l.upvals[i]->v != v) + if (c->upvals[i]->v != v) return NULL; /* wrong upvalue; cannot reuse closure */ } } @@ -394,26 +625,28 @@ static Closure *getcached (Proto *p, UpVal **encup, StkId base) { /* ** create a new Lua closure, push it in the stack, and initialize -** its upvalues. Note that the call to 'luaC_barrierproto' must come -** before the assignment to 'p->cache', as the function needs the -** original value of that field. +** its upvalues. Note that the closure is not cached if prototype is +** already black (which means that 'cache' was already cleared by the +** GC). */ static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base, StkId ra) { int nup = p->sizeupvalues; Upvaldesc *uv = p->upvalues; int i; - Closure *ncl = luaF_newLclosure(L, nup); - ncl->l.p = p; + LClosure *ncl = luaF_newLclosure(L, nup); + ncl->p = p; setclLvalue(L, ra, ncl); /* anchor new closure in stack */ for (i = 0; i < nup; i++) { /* fill in its upvalues */ if (uv[i].instack) /* upvalue refers to local variable? */ - ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx); + ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx); else /* get upvalue from enclosing function */ - ncl->l.upvals[i] = encup[uv[i].idx]; + ncl->upvals[i] = encup[uv[i].idx]; + ncl->upvals[i]->refcount++; + /* new closure is white, so we do not need a barrier here */ } - luaC_barrierproto(L, p, ncl); - p->cache = ncl; /* save it on cache for reuse */ + if (!isblack(p)) /* cache will not break GC invariant? */ + p->cache = ncl; /* save it on cache for reuse */ } @@ -426,8 +659,10 @@ void luaV_finishOp (lua_State *L) { Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */ OpCode op = GET_OPCODE(inst); switch (op) { /* finish its execution */ - case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: - case OP_MOD: case OP_POW: case OP_UNM: case OP_LEN: + case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_IDIV: + case OP_BAND: case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR: + case OP_MOD: case OP_POW: + case OP_UNM: case OP_BNOT: case OP_LEN: case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: { setobjs2s(L, base + GETARG_A(inst), --L->top); break; @@ -435,18 +670,18 @@ void luaV_finishOp (lua_State *L) { case OP_LE: case OP_LT: case OP_EQ: { int res = !l_isfalse(L->top - 1); L->top--; - /* metamethod should not be called when operand is K */ - lua_assert(!ISK(GETARG_B(inst))); - if (op == OP_LE && /* "<=" using "<" instead? */ - ttisnil(luaT_gettmbyobj(L, base + GETARG_B(inst), TM_LE))) - res = !res; /* invert result */ + if (ci->callstatus & CIST_LEQ) { /* "<=" using "<" instead? */ + lua_assert(op == OP_LE); + ci->callstatus ^= CIST_LEQ; /* clear mark */ + res = !res; /* negate result */ + } lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP); if (res != GETARG_A(inst)) /* condition failed? */ ci->u.l.savedpc++; /* skip jump instruction */ break; } case OP_CONCAT: { - StkId top = L->top - 1; /* top when 'call_binTM' was called */ + StkId top = L->top - 1; /* top when 'luaT_trybinTM' was called */ int b = GETARG_B(inst); /* first element to concatenate */ int total = cast_int(top - 1 - (base + b)); /* yet to concatenate */ setobj2s(L, top - 2, top); /* put TM result in proper position */ @@ -477,31 +712,32 @@ void luaV_finishOp (lua_State *L) { + /* -** some macros for common tasks in `luaV_execute' +** {================================================================== +** Function 'luaV_execute': main interpreter loop +** =================================================================== */ -#if !defined luai_runtimecheck -#define luai_runtimecheck(L, c) /* void */ -#endif + +/* +** some macros for common tasks in 'luaV_execute' +*/ #define RA(i) (base+GETARG_A(i)) -/* to be used after possible stack reallocation */ #define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i)) #define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i)) #define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \ ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i)) #define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \ ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i)) -#define KBx(i) \ - (k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++))) /* execute a jump instruction */ #define dojump(ci,i,e) \ { int a = GETARG_A(i); \ - if (a > 0) luaF_close(L, ci->u.l.base + a - 1); \ + if (a != 0) luaF_close(L, ci->u.l.base + a - 1); \ ci->u.l.savedpc += GETARG_sBx(i) + e; } /* for test instructions, execute the jump instruction that follows it */ @@ -511,96 +747,124 @@ void luaV_finishOp (lua_State *L) { #define Protect(x) { {x;}; base = ci->u.l.base; } #define checkGC(L,c) \ - Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \ - luaC_step(L); \ - L->top = ci->top;}) /* restore top */ \ - luai_threadyield(L); ) + { luaC_condGC(L, L->top = (c), /* limit of live values */ \ + Protect(L->top = ci->top)); /* restore top */ \ + luai_threadyield(L); } + + +/* fetch an instruction and prepare its execution */ +#define vmfetch() { \ + i = *(ci->u.l.savedpc++); \ + if (L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) \ + Protect(luaG_traceexec(L)); \ + ra = RA(i); /* WARNING: any stack reallocation invalidates 'ra' */ \ + lua_assert(base == ci->u.l.base); \ + lua_assert(base <= L->top && L->top < L->stack + L->stacksize); \ +} +#define vmdispatch(o) switch(o) +#define vmcase(l) case l: +#define vmbreak break -#define arith_op(op,tm) { \ - TValue *rb = RKB(i); \ - TValue *rc = RKC(i); \ - if (ttisnumber(rb) && ttisnumber(rc)) { \ - lua_Number nb = nvalue(rb), nc = nvalue(rc); \ - setnvalue(ra, op(L, nb, nc)); \ - } \ - else { Protect(luaV_arith(L, ra, rb, rc, tm)); } } + +/* +** copy of 'luaV_gettable', but protecting the call to potential +** metamethod (which can reallocate the stack) +*/ +#define gettableProtected(L,t,k,v) { const TValue *slot; \ + if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \ + else Protect(luaV_finishget(L,t,k,v,slot)); } + + +/* same for 'luaV_settable' */ +#define settableProtected(L,t,k,v) { const TValue *slot; \ + if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \ + Protect(luaV_finishset(L,t,k,v,slot)); } -#define vmdispatch(o) switch(o) -#define vmcase(l,b) case l: {b} break; -#define vmcasenb(l,b) case l: {b} /* nb = no break */ void luaV_execute (lua_State *L) { CallInfo *ci = L->ci; LClosure *cl; TValue *k; StkId base; + ci->callstatus |= CIST_FRESH; /* fresh invocation of 'luaV_execute" */ newframe: /* reentry point when frame changes (call/return) */ lua_assert(ci == L->ci); - cl = clLvalue(ci->func); - k = cl->p->k; - base = ci->u.l.base; + cl = clLvalue(ci->func); /* local reference to function's closure */ + k = cl->p->k; /* local reference to function's constant table */ + base = ci->u.l.base; /* local copy of function's base */ /* main loop of interpreter */ for (;;) { - Instruction i = *(ci->u.l.savedpc++); + Instruction i; StkId ra; - if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && - (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { - Protect(traceexec(L)); - } - /* WARNING: several calls may realloc the stack and invalidate `ra' */ - ra = RA(i); - lua_assert(base == ci->u.l.base); - lua_assert(base <= L->top && L->top < L->stack + L->stacksize); + vmfetch(); vmdispatch (GET_OPCODE(i)) { - vmcase(OP_MOVE, + vmcase(OP_MOVE) { setobjs2s(L, ra, RB(i)); - ) - vmcase(OP_LOADK, + vmbreak; + } + vmcase(OP_LOADK) { TValue *rb = k + GETARG_Bx(i); setobj2s(L, ra, rb); - ) - vmcase(OP_LOADKX, + vmbreak; + } + vmcase(OP_LOADKX) { TValue *rb; lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); rb = k + GETARG_Ax(*ci->u.l.savedpc++); setobj2s(L, ra, rb); - ) - vmcase(OP_LOADBOOL, + vmbreak; + } + vmcase(OP_LOADBOOL) { setbvalue(ra, GETARG_B(i)); if (GETARG_C(i)) ci->u.l.savedpc++; /* skip next instruction (if C) */ - ) - vmcase(OP_LOADNIL, + vmbreak; + } + vmcase(OP_LOADNIL) { int b = GETARG_B(i); do { setnilvalue(ra++); } while (b--); - ) - vmcase(OP_GETUPVAL, + vmbreak; + } + vmcase(OP_GETUPVAL) { int b = GETARG_B(i); setobj2s(L, ra, cl->upvals[b]->v); - ) - vmcase(OP_GETTABUP, - int b = GETARG_B(i); - Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra)); - ) - vmcase(OP_GETTABLE, - Protect(luaV_gettable(L, RB(i), RKC(i), ra)); - ) - vmcase(OP_SETTABUP, - int a = GETARG_A(i); - Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i))); - ) - vmcase(OP_SETUPVAL, + vmbreak; + } + vmcase(OP_GETTABUP) { + TValue *upval = cl->upvals[GETARG_B(i)]->v; + TValue *rc = RKC(i); + gettableProtected(L, upval, rc, ra); + vmbreak; + } + vmcase(OP_GETTABLE) { + StkId rb = RB(i); + TValue *rc = RKC(i); + gettableProtected(L, rb, rc, ra); + vmbreak; + } + vmcase(OP_SETTABUP) { + TValue *upval = cl->upvals[GETARG_A(i)]->v; + TValue *rb = RKB(i); + TValue *rc = RKC(i); + settableProtected(L, upval, rb, rc); + vmbreak; + } + vmcase(OP_SETUPVAL) { UpVal *uv = cl->upvals[GETARG_B(i)]; setobj(L, uv->v, ra); - luaC_barrier(L, uv, ra); - ) - vmcase(OP_SETTABLE, - Protect(luaV_settable(L, ra, RKB(i), RKC(i))); - ) - vmcase(OP_NEWTABLE, + luaC_upvalbarrier(L, uv); + vmbreak; + } + vmcase(OP_SETTABLE) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + settableProtected(L, ra, rb, rc); + vmbreak; + } + vmcase(OP_NEWTABLE) { int b = GETARG_B(i); int c = GETARG_C(i); Table *t = luaH_new(L); @@ -608,96 +872,252 @@ void luaV_execute (lua_State *L) { if (b != 0 || c != 0) luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c)); checkGC(L, ra + 1); - ) - vmcase(OP_SELF, + vmbreak; + } + vmcase(OP_SELF) { + const TValue *aux; StkId rb = RB(i); - setobjs2s(L, ra+1, rb); - Protect(luaV_gettable(L, rb, RKC(i), ra)); - ) - vmcase(OP_ADD, - arith_op(luai_numadd, TM_ADD); - ) - vmcase(OP_SUB, - arith_op(luai_numsub, TM_SUB); - ) - vmcase(OP_MUL, - arith_op(luai_nummul, TM_MUL); - ) - vmcase(OP_DIV, - arith_op(luai_numdiv, TM_DIV); - ) - vmcase(OP_MOD, - arith_op(luai_nummod, TM_MOD); - ) - vmcase(OP_POW, - arith_op(luai_numpow, TM_POW); - ) - vmcase(OP_UNM, + TValue *rc = RKC(i); + TString *key = tsvalue(rc); /* key must be a string */ + setobjs2s(L, ra + 1, rb); + if (luaV_fastget(L, rb, key, aux, luaH_getstr)) { + setobj2s(L, ra, aux); + } + else Protect(luaV_finishget(L, rb, rc, ra, aux)); + vmbreak; + } + vmcase(OP_ADD) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Number nb; lua_Number nc; + if (ttisinteger(rb) && ttisinteger(rc)) { + lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); + setivalue(ra, intop(+, ib, ic)); + } + else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { + setfltvalue(ra, luai_numadd(L, nb, nc)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_ADD)); } + vmbreak; + } + vmcase(OP_SUB) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Number nb; lua_Number nc; + if (ttisinteger(rb) && ttisinteger(rc)) { + lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); + setivalue(ra, intop(-, ib, ic)); + } + else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { + setfltvalue(ra, luai_numsub(L, nb, nc)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SUB)); } + vmbreak; + } + vmcase(OP_MUL) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Number nb; lua_Number nc; + if (ttisinteger(rb) && ttisinteger(rc)) { + lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); + setivalue(ra, intop(*, ib, ic)); + } + else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { + setfltvalue(ra, luai_nummul(L, nb, nc)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_MUL)); } + vmbreak; + } + vmcase(OP_DIV) { /* float division (always with floats) */ + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Number nb; lua_Number nc; + if (tonumber(rb, &nb) && tonumber(rc, &nc)) { + setfltvalue(ra, luai_numdiv(L, nb, nc)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_DIV)); } + vmbreak; + } + vmcase(OP_BAND) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Integer ib; lua_Integer ic; + if (tointeger(rb, &ib) && tointeger(rc, &ic)) { + setivalue(ra, intop(&, ib, ic)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BAND)); } + vmbreak; + } + vmcase(OP_BOR) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Integer ib; lua_Integer ic; + if (tointeger(rb, &ib) && tointeger(rc, &ic)) { + setivalue(ra, intop(|, ib, ic)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BOR)); } + vmbreak; + } + vmcase(OP_BXOR) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Integer ib; lua_Integer ic; + if (tointeger(rb, &ib) && tointeger(rc, &ic)) { + setivalue(ra, intop(^, ib, ic)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BXOR)); } + vmbreak; + } + vmcase(OP_SHL) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Integer ib; lua_Integer ic; + if (tointeger(rb, &ib) && tointeger(rc, &ic)) { + setivalue(ra, luaV_shiftl(ib, ic)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHL)); } + vmbreak; + } + vmcase(OP_SHR) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Integer ib; lua_Integer ic; + if (tointeger(rb, &ib) && tointeger(rc, &ic)) { + setivalue(ra, luaV_shiftl(ib, -ic)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHR)); } + vmbreak; + } + vmcase(OP_MOD) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Number nb; lua_Number nc; + if (ttisinteger(rb) && ttisinteger(rc)) { + lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); + setivalue(ra, luaV_mod(L, ib, ic)); + } + else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { + lua_Number m; + luai_nummod(L, nb, nc, m); + setfltvalue(ra, m); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_MOD)); } + vmbreak; + } + vmcase(OP_IDIV) { /* floor division */ + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Number nb; lua_Number nc; + if (ttisinteger(rb) && ttisinteger(rc)) { + lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); + setivalue(ra, luaV_div(L, ib, ic)); + } + else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { + setfltvalue(ra, luai_numidiv(L, nb, nc)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_IDIV)); } + vmbreak; + } + vmcase(OP_POW) { + TValue *rb = RKB(i); + TValue *rc = RKC(i); + lua_Number nb; lua_Number nc; + if (tonumber(rb, &nb) && tonumber(rc, &nc)) { + setfltvalue(ra, luai_numpow(L, nb, nc)); + } + else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_POW)); } + vmbreak; + } + vmcase(OP_UNM) { TValue *rb = RB(i); - if (ttisnumber(rb)) { - lua_Number nb = nvalue(rb); - setnvalue(ra, luai_numunm(L, nb)); + lua_Number nb; + if (ttisinteger(rb)) { + lua_Integer ib = ivalue(rb); + setivalue(ra, intop(-, 0, ib)); + } + else if (tonumber(rb, &nb)) { + setfltvalue(ra, luai_numunm(L, nb)); } else { - Protect(luaV_arith(L, ra, rb, rb, TM_UNM)); + Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM)); } - ) - vmcase(OP_NOT, + vmbreak; + } + vmcase(OP_BNOT) { + TValue *rb = RB(i); + lua_Integer ib; + if (tointeger(rb, &ib)) { + setivalue(ra, intop(^, ~l_castS2U(0), ib)); + } + else { + Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT)); + } + vmbreak; + } + vmcase(OP_NOT) { TValue *rb = RB(i); int res = l_isfalse(rb); /* next assignment may change this value */ setbvalue(ra, res); - ) - vmcase(OP_LEN, + vmbreak; + } + vmcase(OP_LEN) { Protect(luaV_objlen(L, ra, RB(i))); - ) - vmcase(OP_CONCAT, + vmbreak; + } + vmcase(OP_CONCAT) { int b = GETARG_B(i); int c = GETARG_C(i); StkId rb; L->top = base + c + 1; /* mark the end of concat operands */ Protect(luaV_concat(L, c - b + 1)); - ra = RA(i); /* 'luav_concat' may invoke TMs and move the stack */ - rb = b + base; + ra = RA(i); /* 'luaV_concat' may invoke TMs and move the stack */ + rb = base + b; setobjs2s(L, ra, rb); checkGC(L, (ra >= rb ? ra + 1 : rb)); L->top = ci->top; /* restore top */ - ) - vmcase(OP_JMP, + vmbreak; + } + vmcase(OP_JMP) { dojump(ci, i, 0); - ) - vmcase(OP_EQ, + vmbreak; + } + vmcase(OP_EQ) { TValue *rb = RKB(i); TValue *rc = RKC(i); Protect( - if (cast_int(equalobj(L, rb, rc)) != GETARG_A(i)) + if (luaV_equalobj(L, rb, rc) != GETARG_A(i)) ci->u.l.savedpc++; else donextjump(ci); ) - ) - vmcase(OP_LT, + vmbreak; + } + vmcase(OP_LT) { Protect( if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) ci->u.l.savedpc++; else donextjump(ci); ) - ) - vmcase(OP_LE, + vmbreak; + } + vmcase(OP_LE) { Protect( if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) ci->u.l.savedpc++; else donextjump(ci); ) - ) - vmcase(OP_TEST, + vmbreak; + } + vmcase(OP_TEST) { if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra)) ci->u.l.savedpc++; else donextjump(ci); - ) - vmcase(OP_TESTSET, + vmbreak; + } + vmcase(OP_TESTSET) { TValue *rb = RB(i); if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb)) ci->u.l.savedpc++; @@ -705,27 +1125,30 @@ void luaV_execute (lua_State *L) { setobjs2s(L, ra, rb); donextjump(ci); } - ) - vmcase(OP_CALL, + vmbreak; + } + vmcase(OP_CALL) { int b = GETARG_B(i); int nresults = GETARG_C(i) - 1; if (b != 0) L->top = ra+b; /* else previous instruction set top */ if (luaD_precall(L, ra, nresults)) { /* C function? */ - if (nresults >= 0) L->top = ci->top; /* adjust results */ - base = ci->u.l.base; + if (nresults >= 0) + L->top = ci->top; /* adjust results */ + Protect((void)0); /* update 'base' */ } else { /* Lua function */ ci = L->ci; - ci->callstatus |= CIST_REENTRY; goto newframe; /* restart luaV_execute over new Lua function */ } - ) - vmcase(OP_TAILCALL, + vmbreak; + } + vmcase(OP_TAILCALL) { int b = GETARG_B(i); if (b != 0) L->top = ra+b; /* else previous instruction set top */ lua_assert(GETARG_C(i) - 1 == LUA_MULTRET); - if (luaD_precall(L, ra, LUA_MULTRET)) /* C function? */ - base = ci->u.l.base; + if (luaD_precall(L, ra, LUA_MULTRET)) { /* C function? */ + Protect((void)0); /* update 'base' */ + } else { /* tail call: put called frame (n) in place of caller one (o) */ CallInfo *nci = L->ci; /* called frame */ @@ -748,13 +1171,13 @@ void luaV_execute (lua_State *L) { lua_assert(L->top == oci->u.l.base + getproto(ofunc)->maxstacksize); goto newframe; /* restart luaV_execute over new Lua function */ } - ) - vmcasenb(OP_RETURN, + vmbreak; + } + vmcase(OP_RETURN) { int b = GETARG_B(i); - if (b != 0) L->top = ra+b-1; if (cl->p->sizep > 0) luaF_close(L, base); - b = luaD_poscall(L, ra); - if (!(ci->callstatus & CIST_REENTRY)) /* 'ci' still the called one */ + b = luaD_poscall(L, ci, ra, (b != 0 ? b - 1 : cast_int(L->top - ra))); + if (ci->callstatus & CIST_FRESH) /* local 'ci' still from callee */ return; /* external invocation: return */ else { /* invocation via reentry: continue execution */ ci = L->ci; @@ -763,105 +1186,137 @@ void luaV_execute (lua_State *L) { lua_assert(GET_OPCODE(*((ci)->u.l.savedpc - 1)) == OP_CALL); goto newframe; /* restart luaV_execute over new Lua function */ } - ) - vmcase(OP_FORLOOP, - lua_Number step = nvalue(ra+2); - lua_Number idx = luai_numadd(L, nvalue(ra), step); /* increment index */ - lua_Number limit = nvalue(ra+1); - if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit) - : luai_numle(L, limit, idx)) { - ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ - setnvalue(ra, idx); /* update internal index... */ - setnvalue(ra+3, idx); /* ...and external index */ - } - ) - vmcase(OP_FORPREP, - const TValue *init = ra; - const TValue *plimit = ra+1; - const TValue *pstep = ra+2; - if (!tonumber(init, ra)) - luaG_runerror(L, LUA_QL("for") " initial value must be a number"); - else if (!tonumber(plimit, ra+1)) - luaG_runerror(L, LUA_QL("for") " limit must be a number"); - else if (!tonumber(pstep, ra+2)) - luaG_runerror(L, LUA_QL("for") " step must be a number"); - setnvalue(ra, luai_numsub(L, nvalue(ra), nvalue(pstep))); + } + vmcase(OP_FORLOOP) { + if (ttisinteger(ra)) { /* integer loop? */ + lua_Integer step = ivalue(ra + 2); + lua_Integer idx = intop(+, ivalue(ra), step); /* increment index */ + lua_Integer limit = ivalue(ra + 1); + if ((0 < step) ? (idx <= limit) : (limit <= idx)) { + ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ + chgivalue(ra, idx); /* update internal index... */ + setivalue(ra + 3, idx); /* ...and external index */ + } + } + else { /* floating loop */ + lua_Number step = fltvalue(ra + 2); + lua_Number idx = luai_numadd(L, fltvalue(ra), step); /* inc. index */ + lua_Number limit = fltvalue(ra + 1); + if (luai_numlt(0, step) ? luai_numle(idx, limit) + : luai_numle(limit, idx)) { + ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ + chgfltvalue(ra, idx); /* update internal index... */ + setfltvalue(ra + 3, idx); /* ...and external index */ + } + } + vmbreak; + } + vmcase(OP_FORPREP) { + TValue *init = ra; + TValue *plimit = ra + 1; + TValue *pstep = ra + 2; + lua_Integer ilimit; + int stopnow; + if (ttisinteger(init) && ttisinteger(pstep) && + forlimit(plimit, &ilimit, ivalue(pstep), &stopnow)) { + /* all values are integer */ + lua_Integer initv = (stopnow ? 0 : ivalue(init)); + setivalue(plimit, ilimit); + setivalue(init, intop(-, initv, ivalue(pstep))); + } + else { /* try making all values floats */ + lua_Number ninit; lua_Number nlimit; lua_Number nstep; + if (!tonumber(plimit, &nlimit)) + luaG_runerror(L, "'for' limit must be a number"); + setfltvalue(plimit, nlimit); + if (!tonumber(pstep, &nstep)) + luaG_runerror(L, "'for' step must be a number"); + setfltvalue(pstep, nstep); + if (!tonumber(init, &ninit)) + luaG_runerror(L, "'for' initial value must be a number"); + setfltvalue(init, luai_numsub(L, ninit, nstep)); + } ci->u.l.savedpc += GETARG_sBx(i); - ) - vmcasenb(OP_TFORCALL, + vmbreak; + } + vmcase(OP_TFORCALL) { StkId cb = ra + 3; /* call base */ setobjs2s(L, cb+2, ra+2); setobjs2s(L, cb+1, ra+1); setobjs2s(L, cb, ra); L->top = cb + 3; /* func. + 2 args (state and index) */ - Protect(luaD_call(L, cb, GETARG_C(i), 1)); + Protect(luaD_call(L, cb, GETARG_C(i))); L->top = ci->top; i = *(ci->u.l.savedpc++); /* go to next instruction */ ra = RA(i); lua_assert(GET_OPCODE(i) == OP_TFORLOOP); goto l_tforloop; - ) - vmcase(OP_TFORLOOP, + } + vmcase(OP_TFORLOOP) { l_tforloop: if (!ttisnil(ra + 1)) { /* continue loop? */ setobjs2s(L, ra, ra + 1); /* save control variable */ ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ } - ) - vmcase(OP_SETLIST, + vmbreak; + } + vmcase(OP_SETLIST) { int n = GETARG_B(i); int c = GETARG_C(i); - int last; + unsigned int last; Table *h; if (n == 0) n = cast_int(L->top - ra) - 1; if (c == 0) { lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); c = GETARG_Ax(*ci->u.l.savedpc++); } - luai_runtimecheck(L, ttistable(ra)); h = hvalue(ra); last = ((c-1)*LFIELDS_PER_FLUSH) + n; if (last > h->sizearray) /* needs more space? */ - luaH_resizearray(L, h, last); /* pre-allocate it at once */ + luaH_resizearray(L, h, last); /* preallocate it at once */ for (; n > 0; n--) { TValue *val = ra+n; luaH_setint(L, h, last--, val); - luaC_barrierback(L, obj2gco(h), val); + luaC_barrierback(L, h, val); } L->top = ci->top; /* correct top (in case of previous open call) */ - ) - vmcase(OP_CLOSURE, + vmbreak; + } + vmcase(OP_CLOSURE) { Proto *p = cl->p->p[GETARG_Bx(i)]; - Closure *ncl = getcached(p, cl->upvals, base); /* cached closure */ + LClosure *ncl = getcached(p, cl->upvals, base); /* cached closure */ if (ncl == NULL) /* no match? */ pushclosure(L, p, cl->upvals, base, ra); /* create a new one */ else setclLvalue(L, ra, ncl); /* push cashed closure */ checkGC(L, ra + 1); - ) - vmcase(OP_VARARG, - int b = GETARG_B(i) - 1; + vmbreak; + } + vmcase(OP_VARARG) { + int b = GETARG_B(i) - 1; /* required results */ int j; int n = cast_int(base - ci->func) - cl->p->numparams - 1; + if (n < 0) /* less arguments than parameters? */ + n = 0; /* no vararg arguments */ if (b < 0) { /* B == 0? */ b = n; /* get all var. arguments */ Protect(luaD_checkstack(L, n)); ra = RA(i); /* previous call may change the stack */ L->top = ra + n; } - for (j = 0; j < b; j++) { - if (j < n) { - setobjs2s(L, ra + j, base - n + j); - } - else { - setnilvalue(ra + j); - } - } - ) - vmcase(OP_EXTRAARG, + for (j = 0; j < b && j < n; j++) + setobjs2s(L, ra + j, base - n + j); + for (; j < b; j++) /* complete required results with nil */ + setnilvalue(ra + j); + vmbreak; + } + vmcase(OP_EXTRAARG) { lua_assert(0); - ) + vmbreak; + } } } } +/* }================================================================== */ + diff --git a/depends/lua/src/lzio.c b/depends/lua/src/lzio.c index 20efea9830..6f79094410 100644 --- a/depends/lua/src/lzio.c +++ b/depends/lua/src/lzio.c @@ -1,15 +1,17 @@ /* -** $Id: lzio.c,v 1.35.1.1 2013/04/12 18:48:47 roberto Exp $ +** $Id: lzio.c,v 1.37.1.1 2017/04/19 17:20:42 roberto Exp $ ** Buffered streams ** See Copyright Notice in lua.h */ - -#include - #define lzio_c #define LUA_CORE +#include "lprefix.h" + + +#include + #include "lua.h" #include "llimits.h" @@ -64,13 +66,3 @@ size_t luaZ_read (ZIO *z, void *b, size_t n) { return 0; } -/* ------------------------------------------------------------------------ */ -char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) { - if (n > buff->buffsize) { - if (n < LUA_MINBUFFER) n = LUA_MINBUFFER; - luaZ_resizebuffer(L, buff, n); - } - return buff->buffer; -} - - diff --git a/depends/luacov b/depends/luacov new file mode 160000 index 0000000000..e09ee3fa2e --- /dev/null +++ b/depends/luacov @@ -0,0 +1 @@ +Subproject commit e09ee3fa2e3366d148f94c6a5969c9896126e83a diff --git a/depends/md5/CMakeLists.txt b/depends/md5/CMakeLists.txt index 69e0cf0b33..55c0bf6c1b 100644 --- a/depends/md5/CMakeLists.txt +++ b/depends/md5/CMakeLists.txt @@ -1,3 +1,7 @@ project(dfhack-md5) -ADD_LIBRARY(dfhack-md5 STATIC EXCLUDE_FROM_ALL md5.cpp md5wrapper.cpp) -IDE_FOLDER(dfhack-md5 "Depends") \ No newline at end of file +add_library(dfhack-md5 STATIC EXCLUDE_FROM_ALL md5.cpp md5wrapper.cpp) +target_include_directories(dfhack-md5 INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}) +ide_folder(dfhack-md5 "Depends") +if(UNIX) + set_target_properties(dfhack-md5 PROPERTIES COMPILE_FLAGS "-Wno-strict-aliasing") +endif() diff --git a/depends/md5/md5.cpp b/depends/md5/md5.cpp index 5ee4fb45ff..8aa9ba38c8 100644 --- a/depends/md5/md5.cpp +++ b/depends/md5/md5.cpp @@ -135,7 +135,7 @@ void MD5Final(unsigned char digest[16], MD5Context *ctx) MD5Transform(ctx->buf, (uint32_t *) ctx->in); byteReverse((unsigned char *) ctx->buf, 4); memcpy(digest, ctx->buf, 16); - memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */ + memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */ } @@ -158,7 +158,7 @@ void MD5Final(unsigned char digest[16], MD5Context *ctx) */ void MD5Transform(uint32_t buf[4], uint32_t in[16]) { - register uint32_t a, b, c, d; + uint32_t a, b, c, d; a = buf[0]; b = buf[1]; diff --git a/depends/md5/md5wrapper.cpp b/depends/md5/md5wrapper.cpp index 7feb25035c..7e64f79148 100644 --- a/depends/md5/md5wrapper.cpp +++ b/depends/md5/md5wrapper.cpp @@ -16,10 +16,6 @@ * Petr Mrázek */ -#if defined(_MSC_VER) && _MSC_VER >= 1400 -#define _CRT_SECURE_NO_WARNINGS -#endif - //---------------------------------------------------------------------- //basic includes #include diff --git a/depends/protobuf/CMakeLists.txt b/depends/protobuf/CMakeLists.txt index 4fec34125e..1d1796d1c8 100644 --- a/depends/protobuf/CMakeLists.txt +++ b/depends/protobuf/CMakeLists.txt @@ -1,253 +1,196 @@ -PROJECT(protobuf) - -#Protocol buffers use C++0x hash maps, so we need to look for those. This is a rewrite of stl_hash.m4 in CMake. -IF(CMAKE_COMPILER_IS_GNUCC) - EXECUTE_PROCESS(COMMAND ${CMAKE_C_COMPILER} -dumpversion - OUTPUT_VARIABLE GCC_VERSION) - STRING(REGEX MATCHALL "[0-9]+" GCC_VERSION_COMPONENTS ${GCC_VERSION}) - LIST(GET GCC_VERSION_COMPONENTS 0 GCC_MAJOR) - LIST(GET GCC_VERSION_COMPONENTS 1 GCC_MINOR) - #IF(GCC_MAJOR LESS 4 OR (GCC_MAJOR EQUAL 4 AND GCC_MINOR LESS 2)) - #GCC is too old - # SET(STL_HASH_OLD_GCC 1) - #ENDIF() - - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x") - SET(HAVE_HASH_MAP 0) - SET(HASH_MAP_CLASS unordered_map) - - #Check for all of the possible combinations of unordered_map and hash_map - - FOREACH(header tr1/unordered_map unordered_map) - FOREACH(namespace std::tr1 std ) - IF(HAVE_HASH_MAP EQUAL 0 AND NOT STL_HASH_OLD_GCC) - CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/testHashMap.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/testHashMap.cpp") - IF(CMAKE_CROSSCOMPILING) - TRY_COMPILE(HASH_MAP_COMPILE_RESULT ${PROJECT_BINARY_DIR}/CMakeTmp "${CMAKE_CURRENT_BINARY_DIR}/testHashMap.cpp") - SET(HASH_MAP_RUN_RESULT ${HASH_MAP_COMPILE_RESULT}) - ELSE() - TRY_RUN(HASH_MAP_RUN_RESULT HASH_MAP_COMPILE_RESULT ${PROJECT_BINARY_DIR}/CMakeTmp "${CMAKE_CURRENT_BINARY_DIR}/testHashMap.cpp") - ENDIF() - IF (HASH_MAP_COMPILE_RESULT AND HASH_MAP_RUN_RESULT EQUAL 1) - SET(HASH_MAP_H <${header}>) - STRING(REPLACE "map" "set" HASH_SET_H ${HASH_MAP_H}) - SET(HASH_NAMESPACE ${namespace}) - SET(HASH_MAP_CLASS unordered_map) - SET(HASH_SET_CLASS unordered_set) - SET(HAVE_HASH_MAP 1) - SET(HAVE_HASH_SET 1) - ENDIF() - ENDIF() - ENDFOREACH(namespace) - ENDFOREACH(header) - IF (HAVE_HASH_MAP EQUAL 0) - SET(HASH_MAP_CLASS hash_map) - FOREACH(header ext/hash_map hash_map) - FOREACH(namespace __gnu_cxx "" std stdext) - IF (HAVE_HASH_MAP EQUAL 0) - CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/testHashMap.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/testHashMap.cpp") - TRY_COMPILE(HASH_MAP_COMPILE_RESULT ${PROJECT_BINARY_DIR}/CMakeTmp "${CMAKE_CURRENT_BINARY_DIR}/testHashMap.cpp") - IF (HASH_MAP_COMPILE_RESULT) - SET(HASH_MAP_H <${header}>) - STRING(REPLACE "map" "set" HASH_SET_H ${HASH_MAP_H}) - SET(HASH_NAMESPACE ${namespace}) - SET(HASH_MAP_CLASS hash_map) - SET(HASH_SET_CLASS hash_set) - SET(HAVE_HASH_MAP 1) - SET(HAVE_HASH_SET 1) - ENDIF() - ENDIF() - ENDFOREACH() - ENDFOREACH() - ENDIF() - - IF (HAVE_HASH_MAP EQUAL 0) - MESSAGE(SEND_ERROR "Could not find a working hash map implementation. Please install GCC >= 4.4, and all necessary 32-bit C++ development libraries.") - ENDIF() - - FIND_PACKAGE(Threads) - -ELSE() - SET(HASH_MAP_H ) - SET(HASH_NAMESPACE std) - SET(HASH_SET_H ) - SET(HAVE_HASH_MAP 1) - SET(HAVE_HASH_SET 1) - SET(HASH_MAP_CLASS hash_map) - SET(HASH_SET_CLASS hash_set) -ENDIF() - -CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/config.h.in" "${CMAKE_CURRENT_BINARY_DIR}/config.h") - -SET(LIBPROTOBUF_LITE_HDRS -google/protobuf/io/coded_stream.h -google/protobuf/io/coded_stream_inl.h -google/protobuf/stubs/common.h -${CMAKE_CURRENT_BINARY_DIR}/config.h -google/protobuf/extension_set.h -google/protobuf/generated_message_util.h -google/protobuf/stubs/hash.h -google/protobuf/stubs/map-util.h -google/protobuf/message_lite.h -google/protobuf/stubs/once.h -google/protobuf/repeated_field.h -google/protobuf/stubs/stl_util-inl.h -google/protobuf/wire_format_lite.h -google/protobuf/wire_format_lite_inl.h -google/protobuf/io/zero_copy_stream.h -google/protobuf/io/zero_copy_stream_impl_lite.h -google/protobuf/io/gzip_stream.h -google/protobuf/io/zero_copy_stream_impl.h -) - -SET(LIBPROTOBUF_FULL_HDRS -google/protobuf/descriptor.h -google/protobuf/descriptor.pb.h -google/protobuf/descriptor_database.h -google/protobuf/dynamic_message.h -google/protobuf/generated_message_reflection.h -google/protobuf/compiler/importer.h -google/protobuf/message.h -google/protobuf/compiler/parser.h -google/protobuf/io/printer.h -google/protobuf/reflection_ops.h -google/protobuf/service.h -google/protobuf/stubs/strutil.h -google/protobuf/stubs/substitute.h -google/protobuf/text_format.h -google/protobuf/io/tokenizer.h -google/protobuf/unknown_field_set.h -google/protobuf/wire_format.h -) - -LIST(APPEND LIBPROTOBUF_FULL_HDRS ${LIBPROTOBUF_LITE_HDRS}) - -SET(LIBPROTOBUF_LITE_SRCS -google/protobuf/io/coded_stream.cc -google/protobuf/stubs/common.cc -google/protobuf/extension_set.cc -google/protobuf/generated_message_util.cc -google/protobuf/message_lite.cc -google/protobuf/stubs/once.cc -google/protobuf/repeated_field.cc -google/protobuf/wire_format_lite.cc -google/protobuf/io/zero_copy_stream.cc -google/protobuf/io/zero_copy_stream_impl_lite.cc -google/protobuf/io/gzip_stream.cc -google/protobuf/io/zero_copy_stream_impl.cc -) - -SET(LIBPROTOBUF_FULL_SRCS -google/protobuf/descriptor.cc -google/protobuf/descriptor.pb.cc -google/protobuf/descriptor_database.cc -google/protobuf/dynamic_message.cc -google/protobuf/extension_set_heavy.cc -google/protobuf/generated_message_reflection.cc -google/protobuf/compiler/importer.cc -google/protobuf/io/gzip_stream.cc -google/protobuf/message.cc -google/protobuf/compiler/parser.cc -google/protobuf/io/printer.cc -google/protobuf/reflection_ops.cc -google/protobuf/service.cc -google/protobuf/stubs/structurally_valid.cc -google/protobuf/stubs/strutil.cc -google/protobuf/stubs/substitute.cc -google/protobuf/text_format.cc -google/protobuf/io/tokenizer.cc -google/protobuf/unknown_field_set.cc -google/protobuf/wire_format.cc -google/protobuf/io/zero_copy_stream_impl.cc -) - -SET(LIBPROTOC_HDRS -google/protobuf/compiler/code_generator.h -google/protobuf/compiler/command_line_interface.h -google/protobuf/compiler/cpp/cpp_enum.h -google/protobuf/compiler/cpp/cpp_enum_field.h -google/protobuf/compiler/cpp/cpp_extension.h -google/protobuf/compiler/cpp/cpp_field.h -google/protobuf/compiler/cpp/cpp_file.h -google/protobuf/compiler/cpp/cpp_generator.h -google/protobuf/compiler/cpp/cpp_helpers.h -google/protobuf/compiler/cpp/cpp_message.h -google/protobuf/compiler/cpp/cpp_message_field.h -google/protobuf/compiler/cpp/cpp_primitive_field.h -google/protobuf/compiler/cpp/cpp_service.h -google/protobuf/compiler/cpp/cpp_string_field.h -google/protobuf/compiler/plugin.h -google/protobuf/compiler/plugin.pb.h -google/protobuf/compiler/subprocess.h -google/protobuf/compiler/zip_writer.h -) - -SET(LIBPROTOC_SRCS -google/protobuf/compiler/code_generator.cc -google/protobuf/compiler/command_line_interface.cc -google/protobuf/compiler/cpp/cpp_enum.cc -google/protobuf/compiler/cpp/cpp_enum_field.cc -google/protobuf/compiler/cpp/cpp_extension.cc -google/protobuf/compiler/cpp/cpp_field.cc -google/protobuf/compiler/cpp/cpp_file.cc -google/protobuf/compiler/cpp/cpp_generator.cc -google/protobuf/compiler/cpp/cpp_helpers.cc -google/protobuf/compiler/cpp/cpp_message.cc -google/protobuf/compiler/cpp/cpp_message_field.cc -google/protobuf/compiler/cpp/cpp_primitive_field.cc -google/protobuf/compiler/cpp/cpp_service.cc -google/protobuf/compiler/cpp/cpp_string_field.cc -google/protobuf/compiler/plugin.cc -google/protobuf/compiler/plugin.pb.cc -google/protobuf/compiler/subprocess.cc -google/protobuf/compiler/zip_writer.cc -) - -LIST(APPEND LIBPROTOBUF_FULL_SRCS ${LIBPROTOBUF_LITE_SRCS}) - -IF(CMAKE_COMPILER_IS_GNUCC) - SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Wno-sign-compare") - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-result") -ENDIF() - -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) -SET(PROTOBUF_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}) -INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIRS}) -include_directories(${CMAKE_CURRENT_BINARY_DIR}) - -# Protobuf shared libraries - -ADD_LIBRARY(protobuf SHARED ${LIBPROTOBUF_FULL_SRCS} ${LIBPROTOBUF_FULL_HDRS}) -IDE_FOLDER(protobuf "Depends") -ADD_LIBRARY(protobuf-lite SHARED ${LIBPROTOBUF_LITE_SRCS} ${LIBPROTOBUF_LITE_HDRS}) -IDE_FOLDER(protobuf-lite "Depends") - -SET_TARGET_PROPERTIES(protobuf PROPERTIES COMPILE_DEFINITIONS LIBPROTOBUF_EXPORTS) -SET_TARGET_PROPERTIES(protobuf-lite PROPERTIES COMPILE_DEFINITIONS LIBPROTOBUF_EXPORTS) - -TARGET_LINK_LIBRARIES(protobuf ${CMAKE_THREAD_LIBS_INIT} ${ZLIB_LIBRARIES}) -TARGET_LINK_LIBRARIES(protobuf-lite ${CMAKE_THREAD_LIBS_INIT} ${ZLIB_LIBRARIES}) - -install(TARGETS protobuf-lite - LIBRARY DESTINATION ${DFHACK_LIBRARY_DESTINATION} - RUNTIME DESTINATION ${DFHACK_LIBRARY_DESTINATION}) - -IF(NOT CMAKE_CROSSCOMPILING) - # Protobuf compiler shared library - - ADD_LIBRARY(protoc SHARED ${LIBPROTOC_SRCS} ${LIBPROTOC_HDRS}) - IDE_FOLDER(protoc "Depends") - - SET_TARGET_PROPERTIES(protoc PROPERTIES COMPILE_DEFINITIONS LIBPROTOC_EXPORTS) - TARGET_LINK_LIBRARIES(protoc protobuf) - - # Protobuf compiler executable - - ADD_EXECUTABLE(protoc-bin google/protobuf/compiler/main.cc google/protobuf/compiler/command_line_interface.h google/protobuf/compiler/cpp/cpp_generator.h) - IDE_FOLDER(protoc-bin "Depends") - - SET_TARGET_PROPERTIES(protoc-bin PROPERTIES OUTPUT_NAME protoc) - TARGET_LINK_LIBRARIES(protoc-bin protoc) - - EXPORT(TARGETS protoc-bin FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake ) -ENDIF() +project(protobuf) + +set(HASH_MAP_H ) +set(HASH_SET_H ) +set(HASH_NAMESPACE std) +set(HASH_MAP_CLASS unordered_map) +set(HASH_SET_CLASS unordered_set) +set(HAVE_HASH_MAP 1) +set(HAVE_HASH_SET 1) + +if(HAVE_HASH_MAP EQUAL 0) + message(SEND_ERROR "Could not find a working hash map implementation. Please install GCC >= 4.4, and all necessary 32-bit C++ development libraries.") +endif() + +if(UNIX) + find_package(Threads REQUIRED) +endif() + +configure_file("${CMAKE_CURRENT_SOURCE_DIR}/config.h.in" "${CMAKE_CURRENT_BINARY_DIR}/config.h") + +set(LIBPROTOBUF_LITE_HDRS + google/protobuf/io/coded_stream.h + google/protobuf/io/coded_stream_inl.h + google/protobuf/stubs/common.h + ${CMAKE_CURRENT_BINARY_DIR}/config.h + google/protobuf/extension_set.h + google/protobuf/generated_message_util.h + google/protobuf/stubs/hash.h + google/protobuf/stubs/map-util.h + google/protobuf/message_lite.h + google/protobuf/stubs/once.h + google/protobuf/repeated_field.h + google/protobuf/stubs/stl_util-inl.h + google/protobuf/wire_format_lite.h + google/protobuf/wire_format_lite_inl.h + google/protobuf/io/zero_copy_stream.h + google/protobuf/io/zero_copy_stream_impl_lite.h + google/protobuf/io/gzip_stream.h + google/protobuf/io/zero_copy_stream_impl.h +) + +set(LIBPROTOBUF_FULL_HDRS + google/protobuf/descriptor.h + google/protobuf/descriptor.pb.h + google/protobuf/descriptor_database.h + google/protobuf/dynamic_message.h + google/protobuf/generated_message_reflection.h + google/protobuf/compiler/importer.h + google/protobuf/message.h + google/protobuf/compiler/parser.h + google/protobuf/io/printer.h + google/protobuf/reflection_ops.h + google/protobuf/service.h + google/protobuf/stubs/strutil.h + google/protobuf/stubs/substitute.h + google/protobuf/text_format.h + google/protobuf/io/tokenizer.h + google/protobuf/unknown_field_set.h + google/protobuf/wire_format.h +) + +list(APPEND LIBPROTOBUF_FULL_HDRS ${LIBPROTOBUF_LITE_HDRS}) + +set(LIBPROTOBUF_LITE_SRCS + google/protobuf/io/coded_stream.cc + google/protobuf/stubs/common.cc + google/protobuf/extension_set.cc + google/protobuf/generated_message_util.cc + google/protobuf/message_lite.cc + google/protobuf/stubs/once.cc + google/protobuf/repeated_field.cc + google/protobuf/wire_format_lite.cc + google/protobuf/io/zero_copy_stream.cc + google/protobuf/io/zero_copy_stream_impl_lite.cc + google/protobuf/io/gzip_stream.cc + google/protobuf/io/zero_copy_stream_impl.cc +) + +set(LIBPROTOBUF_FULL_SRCS + google/protobuf/descriptor.cc + google/protobuf/descriptor.pb.cc + google/protobuf/descriptor_database.cc + google/protobuf/dynamic_message.cc + google/protobuf/extension_set_heavy.cc + google/protobuf/generated_message_reflection.cc + google/protobuf/compiler/importer.cc + google/protobuf/io/gzip_stream.cc + google/protobuf/message.cc + google/protobuf/compiler/parser.cc + google/protobuf/io/printer.cc + google/protobuf/reflection_ops.cc + google/protobuf/service.cc + google/protobuf/stubs/structurally_valid.cc + google/protobuf/stubs/strutil.cc + google/protobuf/stubs/substitute.cc + google/protobuf/text_format.cc + google/protobuf/io/tokenizer.cc + google/protobuf/unknown_field_set.cc + google/protobuf/wire_format.cc + google/protobuf/io/zero_copy_stream_impl.cc +) + +set(LIBPROTOC_HDRS + google/protobuf/compiler/code_generator.h + google/protobuf/compiler/command_line_interface.h + google/protobuf/compiler/cpp/cpp_enum.h + google/protobuf/compiler/cpp/cpp_enum_field.h + google/protobuf/compiler/cpp/cpp_extension.h + google/protobuf/compiler/cpp/cpp_field.h + google/protobuf/compiler/cpp/cpp_file.h + google/protobuf/compiler/cpp/cpp_generator.h + google/protobuf/compiler/cpp/cpp_helpers.h + google/protobuf/compiler/cpp/cpp_message.h + google/protobuf/compiler/cpp/cpp_message_field.h + google/protobuf/compiler/cpp/cpp_primitive_field.h + google/protobuf/compiler/cpp/cpp_service.h + google/protobuf/compiler/cpp/cpp_string_field.h + google/protobuf/compiler/plugin.h + google/protobuf/compiler/plugin.pb.h + google/protobuf/compiler/subprocess.h + google/protobuf/compiler/zip_writer.h +) + +set(LIBPROTOC_SRCS + google/protobuf/compiler/code_generator.cc + google/protobuf/compiler/command_line_interface.cc + google/protobuf/compiler/cpp/cpp_enum.cc + google/protobuf/compiler/cpp/cpp_enum_field.cc + google/protobuf/compiler/cpp/cpp_extension.cc + google/protobuf/compiler/cpp/cpp_field.cc + google/protobuf/compiler/cpp/cpp_file.cc + google/protobuf/compiler/cpp/cpp_generator.cc + google/protobuf/compiler/cpp/cpp_helpers.cc + google/protobuf/compiler/cpp/cpp_message.cc + google/protobuf/compiler/cpp/cpp_message_field.cc + google/protobuf/compiler/cpp/cpp_primitive_field.cc + google/protobuf/compiler/cpp/cpp_service.cc + google/protobuf/compiler/cpp/cpp_string_field.cc + google/protobuf/compiler/plugin.cc + google/protobuf/compiler/plugin.pb.cc + google/protobuf/compiler/subprocess.cc + google/protobuf/compiler/zip_writer.cc +) + +list(APPEND LIBPROTOBUF_FULL_SRCS ${LIBPROTOBUF_LITE_SRCS}) + +if(CMAKE_COMPILER_IS_GNUCC) + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-result -Wno-unused-local-typedefs -Wno-misleading-indentation -Wno-class-memaccess -Wno-sign-compare") +elseif(MSVC) + # Disable warnings for integer conversion to smaller type + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4267 /wd4273") +endif() + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) +set(PROTOBUF_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}) +include_directories(${ZLIB_INCLUDE_DIRS}) +include_directories(${CMAKE_CURRENT_BINARY_DIR}) + +# Protobuf shared libraries + +add_library(protobuf-lite SHARED ${LIBPROTOBUF_LITE_SRCS} ${LIBPROTOBUF_LITE_HDRS}) +ide_folder(protobuf-lite "Depends") + +set_target_properties(protobuf-lite PROPERTIES COMPILE_DEFINITIONS LIBPROTOBUF_EXPORTS) + +target_link_libraries(protobuf-lite ${CMAKE_THREAD_LIBS_INIT} ${ZLIB_LIBRARIES}) + +install(TARGETS protobuf-lite + LIBRARY DESTINATION ${DFHACK_LIBRARY_DESTINATION} + RUNTIME DESTINATION ${DFHACK_LIBRARY_DESTINATION}) + +if(NOT CMAKE_CROSSCOMPILING) + add_library(protobuf SHARED ${LIBPROTOBUF_FULL_SRCS} ${LIBPROTOBUF_FULL_HDRS}) + ide_folder(protobuf "Depends") + set_target_properties(protobuf PROPERTIES COMPILE_DEFINITIONS LIBPROTOBUF_EXPORTS) + target_link_libraries(protobuf ${CMAKE_THREAD_LIBS_INIT} ${ZLIB_LIBRARIES}) + + # Protobuf compiler shared library + + add_library(protoc SHARED ${LIBPROTOC_SRCS} ${LIBPROTOC_HDRS}) + ide_folder(protoc "Depends") + + set_target_properties(protoc PROPERTIES COMPILE_DEFINITIONS LIBPROTOC_EXPORTS) + target_link_libraries(protoc protobuf) + + # Protobuf compiler executable + + add_executable(protoc-bin google/protobuf/compiler/main.cc google/protobuf/compiler/command_line_interface.h google/protobuf/compiler/cpp/cpp_generator.h) + ide_folder(protoc-bin "Depends") + + set_target_properties(protoc-bin PROPERTIES OUTPUT_NAME protoc) + target_link_libraries(protoc-bin protoc) + + export(TARGETS protoc-bin FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake ) +endif() diff --git a/depends/protobuf/google/protobuf/message.cc b/depends/protobuf/google/protobuf/message.cc index 91e6878e84..37db6a4852 100644 --- a/depends/protobuf/google/protobuf/message.cc +++ b/depends/protobuf/google/protobuf/message.cc @@ -32,6 +32,7 @@ // Based on original Protocol Buffers design by // Sanjay Ghemawat, Jeff Dean, and others. +#include #include #include diff --git a/depends/protobuf/google/protobuf/repeated_field.h b/depends/protobuf/google/protobuf/repeated_field.h index aed4ce9f25..6377082540 100644 --- a/depends/protobuf/google/protobuf/repeated_field.h +++ b/depends/protobuf/google/protobuf/repeated_field.h @@ -46,6 +46,10 @@ #ifndef GOOGLE_PROTOBUF_REPEATED_FIELD_H__ #define GOOGLE_PROTOBUF_REPEATED_FIELD_H__ +#ifdef __GNUC__ +#pragma GCC system_header +#endif + #include #include #include diff --git a/depends/protobuf/google/protobuf/stubs/hash.h b/depends/protobuf/google/protobuf/stubs/hash.h index 822d605013..0ee778563e 100644 --- a/depends/protobuf/google/protobuf/stubs/hash.h +++ b/depends/protobuf/google/protobuf/stubs/hash.h @@ -1,6 +1,6 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// http://code.google.com/p/protobuf/ +// https://developers.google.com/protocol-buffers/ // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are @@ -37,184 +37,409 @@ #include #include -#include "config.h" -#if defined(HAVE_HASH_MAP) && defined(HAVE_HASH_SET) -#include HASH_MAP_H -#include HASH_SET_H +#define GOOGLE_PROTOBUF_HAVE_HASH_MAP 1 +#define GOOGLE_PROTOBUF_HAVE_HASH_SET 1 + +// Android +#if defined(__ANDROID__) +# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP +# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP + +// Use C++11 unordered_{map|set} if available. +#elif ((_LIBCPP_STD_VER >= 11) || \ + (((__cplusplus >= 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X)) && \ + (__GLIBCXX__ > 20090421))) +# define GOOGLE_PROTOBUF_HAS_CXX11_HASH + +// For XCode >= 4.6: the compiler is clang with libc++. +// For earlier XCode version: the compiler is gcc-4.2.1 with libstdc++. +// libc++ provides and friends even in non C++11 mode, +// and it does not provide the tr1 library. Therefore the following macro +// checks against this special case. +// Note that we should not test the __APPLE_CC__ version number or the +// __clang__ macro, since the new compiler can still use -stdlib=libstdc++, in +// which case is not compilable without -std=c++11 +#elif defined(__APPLE_CC__) +# if __GNUC__ >= 4 +# define GOOGLE_PROTOBUF_HAS_TR1 +# else +// Not tested for gcc < 4... These setting can compile under 4.2.1 though. +# define GOOGLE_PROTOBUF_HASH_NAMESPACE __gnu_cxx +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set +# endif + +// Version checks for gcc. +#elif defined(__GNUC__) +// For GCC 4.x+, use tr1::unordered_map/set; otherwise, follow the +// instructions from: +// https://gcc.gnu.org/onlinedocs/libstdc++/manual/backwards.html +# if __GNUC__ >= 4 +# define GOOGLE_PROTOBUF_HAS_TR1 +# elif __GNUC__ >= 3 +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set +# if __GNUC__ == 3 && __GNUC_MINOR__ == 0 +# define GOOGLE_PROTOBUF_HASH_NAMESPACE std // GCC 3.0 +# else +# define GOOGLE_PROTOBUF_HASH_NAMESPACE __gnu_cxx // GCC 3.1 and later +# endif +# else +# define GOOGLE_PROTOBUF_HASH_NAMESPACE +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set +# endif + +// Version checks for MSC. +// Apparently Microsoft decided to move hash_map *back* to the std namespace in +// MSVC 2010: +// http://blogs.msdn.com/vcblog/archive/2009/05/25/stl-breaking-changes-in-visual-studio-2010-beta-1.aspx +// And.. they are moved back to stdext in MSVC 2013 (haven't checked 2012). That +// said, use unordered_map for MSVC 2010 and beyond is our safest bet. +#elif defined(_MSC_VER) +# if _MSC_VER >= 1900 // Since Visual Studio 2019 +# define GOOGLE_PROTOBUF_HASH_NAMESPACE std +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS unordered_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS unordered_set + +# elif _MSC_VER >= 1600 // Since Visual Studio 2010 +# define GOOGLE_PROTOBUF_HAS_CXX11_HASH +# define GOOGLE_PROTOBUF_HASH_COMPARE std::hash_compare +# elif _MSC_VER >= 1500 // Since Visual Studio 2008 +# define GOOGLE_PROTOBUF_HASH_NAMESPACE stdext +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set +# define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare +# define GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE +# elif _MSC_VER >= 1310 +# define GOOGLE_PROTOBUF_HASH_NAMESPACE stdext +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set +# define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare +# else +# define GOOGLE_PROTOBUF_HASH_NAMESPACE std +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set +# define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare +# endif + +// **ADD NEW COMPILERS SUPPORT HERE.** +// For other compilers, undefine the macro and fallback to use std::map, in +// google/protobuf/stubs/hash.h #else -#define MISSING_HASH -#include -#include +# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP +# undef GOOGLE_PROTOBUF_HAVE_HASH_SET #endif -namespace google { -namespace protobuf { - -#ifdef MISSING_HASH - -// This system doesn't have hash_map or hash_set. Emulate them using map and -// set. - -// Make hash be the same as less. Note that everywhere where custom -// hash functions are defined in the protobuf code, they are also defined such -// that they can be used as "less" functions, which is required by MSVC anyway. -template -struct hash { - // Dummy, just to make derivative hash functions compile. - int operator()(const Key& key) { - GOOGLE_LOG(FATAL) << "Should never be called."; - return 0; - } - - inline bool operator()(const Key& a, const Key& b) const { - return a < b; - } -}; - -// Make sure char* is compared by value. -template <> -struct hash { - // Dummy, just to make derivative hash functions compile. - int operator()(const char* key) { - GOOGLE_LOG(FATAL) << "Should never be called."; - return 0; - } - - inline bool operator()(const char* a, const char* b) const { - return strcmp(a, b) < 0; - } -}; - -template , - typename EqualKey = int > -class hash_map : public std::map { -}; - -template , - typename EqualKey = int > -class hash_set : public std::set { -}; - -#elif defined(_MSC_VER) && !defined(_STLPORT_VERSION) - -template -struct hash : public HASH_NAMESPACE::hash_compare { -}; - -// MSVC's hash_compare hashes based on the string contents but -// compares based on the string pointer. WTF? -class CstringLess { - public: - inline bool operator()(const char* a, const char* b) const { - return strcmp(a, b) < 0; - } -}; - -template <> -struct hash - : public HASH_NAMESPACE::hash_compare { -}; - -template , - typename EqualKey = int > -class hash_map : public HASH_NAMESPACE::hash_map< - Key, Data, HashFcn> { -}; - -template , - typename EqualKey = int > -class hash_set : public HASH_NAMESPACE::hash_set< - Key, HashFcn> { -}; +#if defined(GOOGLE_PROTOBUF_HAS_CXX11_HASH) +# define GOOGLE_PROTOBUF_HASH_NAMESPACE std +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS unordered_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS unordered_set +#elif defined(GOOGLE_PROTOBUF_HAS_TR1) +# define GOOGLE_PROTOBUF_HASH_NAMESPACE std::tr1 +# include +# define GOOGLE_PROTOBUF_HASH_MAP_CLASS unordered_map +# include +# define GOOGLE_PROTOBUF_HASH_SET_CLASS unordered_set +#endif -#else +# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START \ + namespace google { \ + namespace protobuf { +# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END }} -template -struct hash : public HASH_NAMESPACE::hash { -}; - -template -struct hash { - inline size_t operator()(const Key* key) const { - return reinterpret_cast(key); - } -}; - -// Unlike the old SGI version, the TR1 "hash" does not special-case char*. So, -// we go ahead and provide our own implementation. -template <> -struct hash { - inline size_t operator()(const char* str) const { - size_t result = 0; - for (; *str != '\0'; str++) { - result = 5 * result + *str; - } - return result; - } -}; - -template , - typename EqualKey = std::equal_to > -class hash_map : public HASH_NAMESPACE::HASH_MAP_CLASS< - Key, Data, HashFcn, EqualKey> { -}; - -template , - typename EqualKey = std::equal_to > -class hash_set : public HASH_NAMESPACE::HASH_SET_CLASS< - Key, HashFcn, EqualKey> { -}; +#undef GOOGLE_PROTOBUF_HAS_CXX11_HASH +#undef GOOGLE_PROTOBUF_HAS_TR1 +#if defined(GOOGLE_PROTOBUF_HAVE_HASH_MAP) && \ + defined(GOOGLE_PROTOBUF_HAVE_HASH_SET) +#else +#define GOOGLE_PROTOBUF_MISSING_HASH +#include +#include #endif -template <> -struct hash { - inline size_t operator()(const string& key) const { - return hash()(key.c_str()); - } - - static const size_t bucket_size = 4; - static const size_t min_buckets = 8; - inline size_t operator()(const string& a, const string& b) const { - return a < b; - } -}; - -template -struct hash > { - inline size_t operator()(const pair& key) const { - size_t first_hash = hash()(key.first); - size_t second_hash = hash()(key.second); - - // FIXME(kenton): What is the best way to compute this hash? I have - // no idea! This seems a bit better than an XOR. - return first_hash * ((1 << 16) - 1) + second_hash; - } - - static const size_t bucket_size = 4; - static const size_t min_buckets = 8; - inline size_t operator()(const pair& a, - const pair& b) const { - return a < b; - } -}; - -// Used by GCC/SGI STL only. (Why isn't this provided by the standard -// library? :( ) -struct streq { - inline bool operator()(const char* a, const char* b) const { - return strcmp(a, b) == 0; - } -}; - -} // namespace protobuf +namespace google { + namespace protobuf { + +#ifdef GOOGLE_PROTOBUF_MISSING_HASH +#undef GOOGLE_PROTOBUF_MISSING_HASH + + // This system doesn't have hash_map or hash_set. Emulate them using map and + // set. + + // Make hash be the same as less. Note that everywhere where custom + // hash functions are defined in the protobuf code, they are also defined such + // that they can be used as "less" functions, which is required by MSVC anyway. + template + struct hash { + // Dummy, just to make derivative hash functions compile. + int operator()(const Key& key) { + GOOGLE_LOG(FATAL) << "Should never be called."; + return 0; + } + + inline bool operator()(const Key& a, const Key& b) const { + return a < b; + } + }; + + // Make sure char* is compared by value. + template <> + struct hash { + // Dummy, just to make derivative hash functions compile. + int operator()(const char* key) { + GOOGLE_LOG(FATAL) << "Should never be called."; + return 0; + } + + inline bool operator()(const char* a, const char* b) const { + return strcmp(a, b) < 0; + } + }; + + template , + typename EqualKey = std::equal_to, + typename Alloc = std::allocator< std::pair > > + class hash_map : public std::map { + typedef std::map BaseClass; + + public: + hash_map(int a = 0, const HashFcn& b = HashFcn(), + const EqualKey& c = EqualKey(), + const Alloc& d = Alloc()) : BaseClass(b, d) {} + + HashFcn hash_function() const { return HashFcn(); } + }; + + template , + typename EqualKey = std::equal_to > + class hash_set : public std::set { + public: + hash_set(int = 0) {} + + HashFcn hash_function() const { return HashFcn(); } + }; + +#elif defined(_MSC_VER) && _MSC_VER < 1900 && !defined(_STLPORT_VERSION) + + template + struct hash : public GOOGLE_PROTOBUF_HASH_COMPARE { + }; + + // MSVC's hash_compare hashes based on the string contents but + // compares based on the string pointer. WTF? + class CstringLess { + public: + inline bool operator()(const char* a, const char* b) const { + return strcmp(a, b) < 0; + } + }; + + template <> + struct hash + : public GOOGLE_PROTOBUF_HASH_COMPARE {}; + +#ifdef GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE + + template + struct InternalHashCompare : public GOOGLE_PROTOBUF_HASH_COMPARE { + InternalHashCompare() {} + InternalHashCompare(HashFcn hashfcn, EqualKey equalkey) + : hashfcn_(hashfcn), equalkey_(equalkey) {} + size_t operator()(const Key& key) const { return hashfcn_(key); } + bool operator()(const Key& key1, const Key& key2) const { + return !equalkey_(key1, key2); + } + HashFcn hashfcn_; + EqualKey equalkey_; + }; + + template , + typename EqualKey = std::equal_to, + typename Alloc = std::allocator< std::pair > > + class hash_map + : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS< + Key, Data, InternalHashCompare, Alloc> { + typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS< + Key, Data, InternalHashCompare, Alloc> BaseClass; + + public: + hash_map(int a = 0, const HashFcn& b = HashFcn(), + const EqualKey& c = EqualKey(), const Alloc& d = Alloc()) + : BaseClass(InternalHashCompare(b, c), d) {} + + HashFcn hash_function() const { return HashFcn(); } + }; + + template , + typename EqualKey = std::equal_to > + class hash_set + : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS< + Key, InternalHashCompare > { + public: + hash_set(int = 0) {} + + HashFcn hash_function() const { return HashFcn(); } + }; + +#else // GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE + + template , + typename EqualKey = std::equal_to, + typename Alloc = std::allocator< std::pair > > + class hash_map + : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS< + Key, Data, HashFcn, EqualKey, Alloc> { + typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS< + Key, Data, HashFcn, EqualKey, Alloc> BaseClass; + + public: + hash_map(int a = 0, const HashFcn& b = HashFcn(), + const EqualKey& c = EqualKey(), + const Alloc& d = Alloc()) : BaseClass(a, b, c, d) {} + + HashFcn hash_function() const { return HashFcn(); } + }; + + template , + typename EqualKey = std::equal_to > + class hash_set + : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS< + Key, HashFcn, EqualKey> { + public: + hash_set(int = 0) {} + + HashFcn hash_function() const { return HashFcn(); } + }; +#endif // GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE + +#else // defined(_MSC_VER) && !defined(_STLPORT_VERSION) + + template + struct hash : public GOOGLE_PROTOBUF_HASH_NAMESPACE::hash { + }; + + template + struct hash { + inline size_t operator()(const Key* key) const { + return reinterpret_cast(key); + } + }; + + // Unlike the old SGI version, the TR1 "hash" does not special-case char*. So, + // we go ahead and provide our own implementation. + template <> + struct hash { + inline size_t operator()(const char* str) const { + size_t result = 0; + for (; *str != '\0'; str++) { + result = 5 * result + *str; + } + return result; + } + }; + + template<> + struct hash { + size_t operator()(bool x) const { + return static_cast(x); + } + }; + + template , + typename EqualKey = std::equal_to, + typename Alloc = std::allocator< std::pair > > + class hash_map + : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS< + Key, Data, HashFcn, EqualKey, Alloc> { + typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS< + Key, Data, HashFcn, EqualKey, Alloc> BaseClass; + + public: + hash_map(int a = 0, const HashFcn& b = HashFcn(), + const EqualKey& c = EqualKey(), + const Alloc& d = Alloc()) : BaseClass(a, b, c, d) {} + + HashFcn hash_function() const { return HashFcn(); } + }; + + template , + typename EqualKey = std::equal_to > + class hash_set + : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS< + Key, HashFcn, EqualKey> { + public: + hash_set(int = 0) {} + + HashFcn hash_function() const { return HashFcn(); } + }; + +#endif // !GOOGLE_PROTOBUF_MISSING_HASH + + template <> + struct hash { + inline size_t operator()(const string& key) const { + return hash()(key.c_str()); + } + + static const size_t bucket_size = 4; + static const size_t min_buckets = 8; + inline bool operator()(const string& a, const string& b) const { + return a < b; + } + }; + + template + struct hash > { + inline size_t operator()(const pair& key) const { + size_t first_hash = hash()(key.first); + size_t second_hash = hash()(key.second); + + // FIXME(kenton): What is the best way to compute this hash? I have + // no idea! This seems a bit better than an XOR. + return first_hash * ((1 << 16) - 1) + second_hash; + } + + static const size_t bucket_size = 4; + static const size_t min_buckets = 8; + inline bool operator()(const pair& a, + const pair& b) const { + return a < b; + } + }; + + // Used by GCC/SGI STL only. (Why isn't this provided by the standard + // library? :( ) + struct streq { + inline bool operator()(const char* a, const char* b) const { + return strcmp(a, b) == 0; + } + }; + + } // namespace protobuf } // namespace google #endif // GOOGLE_PROTOBUF_STUBS_HASH_H__ diff --git a/depends/sizecheck/CMakeLists.txt b/depends/sizecheck/CMakeLists.txt new file mode 100644 index 0000000000..b0d723631f --- /dev/null +++ b/depends/sizecheck/CMakeLists.txt @@ -0,0 +1,6 @@ +project(sizecheck) +add_library(sizecheck SHARED sizecheck.cpp) +ide_folder(sizecheck "Depends") +install(TARGETS sizecheck + LIBRARY DESTINATION ${DFHACK_LIBRARY_DESTINATION} + RUNTIME DESTINATION ${DFHACK_LIBRARY_DESTINATION}) diff --git a/depends/sizecheck/sizecheck.cpp b/depends/sizecheck/sizecheck.cpp new file mode 100644 index 0000000000..cd38ae9554 --- /dev/null +++ b/depends/sizecheck/sizecheck.cpp @@ -0,0 +1,76 @@ +// adapted from https://github.com/mifki/df-sizecheck/blob/master/b.cpp +// usage: +// linux: PRELOAD_LIB=hack/libsizecheck.so ./dfhack + +#include +#include +#include +#include +#include + +using namespace std; + +const uint32_t MAGIC = 0xdfdf4ac8; +bool initialized = false; +int perturb = -1; + +void init() { +#ifndef _LINUX + if (getenv("MALLOC_PERTURB_")) { + perturb = atoi(getenv("MALLOC_PERTURB_")); + } +#endif + initialized = true; +} + +#ifdef _WIN32 +static int posix_memalign(void **ptr, size_t alignment, size_t size) +{ + if ((*ptr = _aligned_malloc(size, alignment))) + { + return 0; + } + + return errno; +} +#endif + +void* alloc(size_t n) { + if (!initialized) { + init(); + } + void* addr; + if (posix_memalign(&addr, 32, n + 16) != 0) { + return addr; + } + memset(addr, 0, 16); + *(size_t*)addr = n; + *(uint32_t*)((uint8_t*)addr + 8) = MAGIC; + if (perturb > 0) { + memset((uint8_t*)addr + 16, ~(perturb & 0xff), n); + } + return (uint8_t*)addr + 16; +} + +void dealloc(void* addr) { + if (!initialized) { + init(); + } + if (uintptr_t(addr) % 32 == 16 && *(uint32_t*)((uint8_t*)addr - 8) == MAGIC) { + addr = (void*)((uint8_t*)addr - 16); + memset((uint8_t*)addr + 16, perturb & 0xff, *(size_t*)addr); + } + free(addr); +} + +void* operator new (size_t n, const nothrow_t& tag) { + return alloc(n); +} + +void* operator new (size_t n) { + return alloc(n); +} + +void operator delete (void* addr) { + return dealloc(addr); +} diff --git a/depends/tinyxml/CMakeLists.txt b/depends/tinyxml/CMakeLists.txt index 313837cace..b3c2902e44 100644 --- a/depends/tinyxml/CMakeLists.txt +++ b/depends/tinyxml/CMakeLists.txt @@ -1,5 +1,5 @@ if(NOT TinyXML_FOUND) project(dfhack-tinyxml) - ADD_LIBRARY(dfhack-tinyxml STATIC EXCLUDE_FROM_ALL tinystr.cpp tinyxml.cpp tinyxmlerror.cpp tinyxmlparser.cpp) - IDE_FOLDER(dfhack-tinyxml "Depends") + add_library(dfhack-tinyxml STATIC EXCLUDE_FROM_ALL tinystr.cpp tinyxml.cpp tinyxmlerror.cpp tinyxmlparser.cpp) + ide_folder(dfhack-tinyxml "Depends") endif() diff --git a/depends/tinyxml/tinystr.cpp b/depends/tinyxml/tinystr.cpp index 681250714b..0665768205 100644 --- a/depends/tinyxml/tinystr.cpp +++ b/depends/tinyxml/tinystr.cpp @@ -1,6 +1,5 @@ /* www.sourceforge.net/projects/tinyxml -Original file by Yves Berquin. This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any @@ -22,10 +21,6 @@ must not be misrepresented as being the original software. distribution. */ -/* - * THIS FILE WAS ALTERED BY Tyge Løvset, 7. April 2005. - */ - #ifndef TIXML_USE_STL diff --git a/depends/tinyxml/tinystr.h b/depends/tinyxml/tinystr.h index 3c2aa9d54d..89cca33415 100644 --- a/depends/tinyxml/tinystr.h +++ b/depends/tinyxml/tinystr.h @@ -1,6 +1,5 @@ /* www.sourceforge.net/projects/tinyxml -Original file by Yves Berquin. This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any @@ -22,17 +21,6 @@ must not be misrepresented as being the original software. distribution. */ -/* - * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005. - * - * - completely rewritten. compact, clean, and fast implementation. - * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems) - * - fixed reserve() to work as per specification. - * - fixed buggy compares operator==(), operator<(), and operator>() - * - fixed operator+=() to take a const ref argument, following spec. - * - added "copy" constructor with length, and most compare operators. - * - added swap(), clear(), size(), capacity(), operator+(). - */ #ifndef TIXML_USE_STL @@ -106,13 +94,11 @@ class TiXmlString quit(); } - // = operator TiXmlString& operator = (const char * copy) { return assign( copy, (size_type)strlen(copy)); } - // = operator TiXmlString& operator = (const TiXmlString & copy) { return assign(copy.start(), copy.length()); diff --git a/depends/tinyxml/tinyxml.cpp b/depends/tinyxml/tinyxml.cpp index 5de21f6dec..9c161dfcb9 100644 --- a/depends/tinyxml/tinyxml.cpp +++ b/depends/tinyxml/tinyxml.cpp @@ -1,6 +1,6 @@ /* www.sourceforge.net/projects/tinyxml -Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com) +Original code by Lee Thomason (www.grinninglizard.com) This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any @@ -31,6 +31,7 @@ distribution. #include "tinyxml.h" +FILE* TiXmlFOpen( const char* filename, const char* mode ); bool TiXmlBase::condenseWhiteSpace = true; @@ -161,6 +162,7 @@ void TiXmlNode::CopyTo( TiXmlNode* target ) const { target->SetValue (value.c_str() ); target->userData = userData; + target->location = location; } @@ -186,10 +188,11 @@ TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node ) assert( node->parent == 0 || node->parent == this ); assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() ); - if ( node->Type() == TiXmlNode::DOCUMENT ) + if ( node->Type() == TiXmlNode::TINYXML_DOCUMENT ) { delete node; - if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); return 0; } @@ -210,9 +213,10 @@ TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node ) TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis ) { - if ( addThis.Type() == TiXmlNode::DOCUMENT ) + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) { - if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); return 0; } TiXmlNode* node = addThis.Clone(); @@ -228,9 +232,10 @@ TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& if ( !beforeThis || beforeThis->parent != this ) { return 0; } - if ( addThis.Type() == TiXmlNode::DOCUMENT ) + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) { - if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); return 0; } @@ -260,9 +265,10 @@ TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& a if ( !afterThis || afterThis->parent != this ) { return 0; } - if ( addThis.Type() == TiXmlNode::DOCUMENT ) + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) { - if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); return 0; } @@ -289,9 +295,20 @@ TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& a TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis ) { + if ( !replaceThis ) + return 0; + if ( replaceThis->parent != this ) return 0; + if ( withThis.ToDocument() ) { + // A document can never be a child. Thanks to Noam. + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + TiXmlNode* node = withThis.Clone(); if ( !node ) return 0; @@ -317,6 +334,10 @@ TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& wit bool TiXmlNode::RemoveChild( TiXmlNode* removeThis ) { + if ( !removeThis ) { + return false; + } + if ( removeThis->parent != this ) { assert( 0 ); @@ -502,7 +523,7 @@ const TiXmlDocument* TiXmlNode::GetDocument() const TiXmlElement::TiXmlElement (const char * _value) - : TiXmlNode( TiXmlNode::ELEMENT ) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) { firstChild = lastChild = 0; value = _value; @@ -511,7 +532,7 @@ TiXmlElement::TiXmlElement (const char * _value) #ifdef TIXML_USE_STL TiXmlElement::TiXmlElement( const std::string& _value ) - : TiXmlNode( TiXmlNode::ELEMENT ) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) { firstChild = lastChild = 0; value = _value; @@ -520,17 +541,18 @@ TiXmlElement::TiXmlElement( const std::string& _value ) TiXmlElement::TiXmlElement( const TiXmlElement& copy) - : TiXmlNode( TiXmlNode::ELEMENT ) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) { firstChild = lastChild = 0; copy.CopyTo( this ); } -void TiXmlElement::operator=( const TiXmlElement& base ) +TiXmlElement& TiXmlElement::operator=( const TiXmlElement& base ) { ClearThis(); base.CopyTo( this ); + return *this; } @@ -564,9 +586,9 @@ const char* TiXmlElement::Attribute( const char* name ) const #ifdef TIXML_USE_STL const std::string* TiXmlElement::Attribute( const std::string& name ) const { - const TiXmlAttribute* node = attributeSet.Find( name ); - if ( node ) - return &node->ValueStr(); + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( attrib ) + return &attrib->ValueStr(); return 0; } #endif @@ -574,195 +596,202 @@ const std::string* TiXmlElement::Attribute( const std::string& name ) const const char* TiXmlElement::Attribute( const char* name, int* i ) const { - const char* s = Attribute( name ); - if ( i ) - { - if ( s ) { - *i = atoi( s ); - } - else { - *i = 0; + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const char* result = 0; + + if ( attrib ) { + result = attrib->Value(); + if ( i ) { + attrib->QueryIntValue( i ); } } - return s; + return result; } #ifdef TIXML_USE_STL const std::string* TiXmlElement::Attribute( const std::string& name, int* i ) const { - const std::string* s = Attribute( name ); - if ( i ) - { - if ( s ) { - *i = atoi( s->c_str() ); - } - else { - *i = 0; + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const std::string* result = 0; + + if ( attrib ) { + result = &attrib->ValueStr(); + if ( i ) { + attrib->QueryIntValue( i ); } } - return s; + return result; } #endif const char* TiXmlElement::Attribute( const char* name, double* d ) const { - const char* s = Attribute( name ); - if ( d ) - { - if ( s ) { - *d = atof( s ); - } - else { - *d = 0; + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const char* result = 0; + + if ( attrib ) { + result = attrib->Value(); + if ( d ) { + attrib->QueryDoubleValue( d ); } } - return s; + return result; } #ifdef TIXML_USE_STL const std::string* TiXmlElement::Attribute( const std::string& name, double* d ) const { - const std::string* s = Attribute( name ); - if ( d ) - { - if ( s ) { - *d = atof( s->c_str() ); - } - else { - *d = 0; + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const std::string* result = 0; + + if ( attrib ) { + result = &attrib->ValueStr(); + if ( d ) { + attrib->QueryDoubleValue( d ); } } - return s; + return result; } #endif int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryIntValue( ival ); +} + + +int TiXmlElement::QueryUnsignedAttribute( const char* name, unsigned* value ) const { const TiXmlAttribute* node = attributeSet.Find( name ); if ( !node ) return TIXML_NO_ATTRIBUTE; - return node->QueryIntValue( ival ); + + int ival = 0; + int result = node->QueryIntValue( &ival ); + *value = (unsigned)ival; + return result; } -#ifdef TIXML_USE_STL -int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival ) const +int TiXmlElement::QueryBoolAttribute( const char* name, bool* bval ) const { const TiXmlAttribute* node = attributeSet.Find( name ); if ( !node ) return TIXML_NO_ATTRIBUTE; - return node->QueryIntValue( ival ); + + int result = TIXML_WRONG_TYPE; + if ( StringEqual( node->Value(), "true", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "yes", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "1", true, TIXML_ENCODING_UNKNOWN ) ) + { + *bval = true; + result = TIXML_SUCCESS; + } + else if ( StringEqual( node->Value(), "false", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "no", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "0", true, TIXML_ENCODING_UNKNOWN ) ) + { + *bval = false; + result = TIXML_SUCCESS; + } + return result; +} + + + +#ifdef TIXML_USE_STL +int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryIntValue( ival ); } #endif int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const { - const TiXmlAttribute* node = attributeSet.Find( name ); - if ( !node ) + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) return TIXML_NO_ATTRIBUTE; - return node->QueryDoubleValue( dval ); + return attrib->QueryDoubleValue( dval ); } #ifdef TIXML_USE_STL int TiXmlElement::QueryDoubleAttribute( const std::string& name, double* dval ) const { - const TiXmlAttribute* node = attributeSet.Find( name ); - if ( !node ) + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) return TIXML_NO_ATTRIBUTE; - return node->QueryDoubleValue( dval ); + return attrib->QueryDoubleValue( dval ); } #endif void TiXmlElement::SetAttribute( const char * name, int val ) { - char buf[64]; - #if defined(TIXML_SNPRINTF) - TIXML_SNPRINTF( buf, sizeof(buf), "%d", val ); - #else - sprintf( buf, "%d", val ); - #endif - SetAttribute( name, buf ); + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetIntValue( val ); + } } #ifdef TIXML_USE_STL void TiXmlElement::SetAttribute( const std::string& name, int val ) { - std::ostringstream oss; - oss << val; - SetAttribute( name, oss.str() ); + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetIntValue( val ); + } } #endif void TiXmlElement::SetDoubleAttribute( const char * name, double val ) { - char buf[256]; - #if defined(TIXML_SNPRINTF) - TIXML_SNPRINTF( buf, sizeof(buf), "%f", val ); - #else - sprintf( buf, "%f", val ); - #endif - SetAttribute( name, buf ); + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetDoubleValue( val ); + } } -void TiXmlElement::SetAttribute( const char * cname, const char * cvalue ) -{ - #ifdef TIXML_USE_STL - TIXML_STRING _name( cname ); - TIXML_STRING _value( cvalue ); - #else - const char* _name = cname; - const char* _value = cvalue; - #endif - - TiXmlAttribute* node = attributeSet.Find( _name ); - if ( node ) - { - node->SetValue( _value ); - return; +#ifdef TIXML_USE_STL +void TiXmlElement::SetDoubleAttribute( const std::string& name, double val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetDoubleValue( val ); } +} +#endif - TiXmlAttribute* attrib = new TiXmlAttribute( cname, cvalue ); - if ( attrib ) - { - attributeSet.Add( attrib ); - } - else - { - TiXmlDocument* document = GetDocument(); - if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN ); + +void TiXmlElement::SetAttribute( const char * cname, const char * cvalue ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( cname ); + if ( attrib ) { + attrib->SetValue( cvalue ); } } #ifdef TIXML_USE_STL -void TiXmlElement::SetAttribute( const std::string& name, const std::string& _value ) +void TiXmlElement::SetAttribute( const std::string& _name, const std::string& _value ) { - TiXmlAttribute* node = attributeSet.Find( name ); - if ( node ) - { - node->SetValue( _value ); - return; - } - - TiXmlAttribute* attrib = new TiXmlAttribute( name, _value ); - if ( attrib ) - { - attributeSet.Add( attrib ); - } - else - { - TiXmlDocument* document = GetDocument(); - if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN ); + TiXmlAttribute* attrib = attributeSet.FindOrCreate( _name ); + if ( attrib ) { + attrib->SetValue( _value ); } } #endif @@ -881,14 +910,14 @@ const char* TiXmlElement::GetText() const } -TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::DOCUMENT ) +TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) { tabsize = 4; useMicrosoftBOM = false; ClearError(); } -TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::DOCUMENT ) +TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) { tabsize = 4; useMicrosoftBOM = false; @@ -898,7 +927,7 @@ TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode #ifdef TIXML_USE_STL -TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::DOCUMENT ) +TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) { tabsize = 4; useMicrosoftBOM = false; @@ -908,49 +937,33 @@ TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiX #endif -TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::DOCUMENT ) +TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) { copy.CopyTo( this ); } -void TiXmlDocument::operator=( const TiXmlDocument& copy ) +TiXmlDocument& TiXmlDocument::operator=( const TiXmlDocument& copy ) { Clear(); copy.CopyTo( this ); + return *this; } bool TiXmlDocument::LoadFile( TiXmlEncoding encoding ) { - // See STL_STRING_BUG below. - //StringToBuffer buf( value ); - return LoadFile( Value(), encoding ); } bool TiXmlDocument::SaveFile() const { - // See STL_STRING_BUG below. -// StringToBuffer buf( value ); -// -// if ( buf.buffer && SaveFile( buf.buffer ) ) -// return true; -// -// return false; return SaveFile( Value() ); } bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding ) { - // There was a really terrifying little bug here. The code: - // value = filename - // in the STL case, cause the assignment method of the std::string to - // be called. What is strange, is that the std::string had the same - // address as it's c_str() method, and so bad things happen. Looks - // like a bug in the Microsoft STL implementation. - // Add an extra string to avoid the crash. TIXML_STRING filename( _filename ); value = filename; @@ -995,11 +1008,6 @@ bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding ) return false; } - // If we have a file, assume it is all one big XML file, and read it in. - // The document parser may decide the document ends sooner than the entire file, however. - TIXML_STRING data; - data.reserve( length ); - // Subtle bug here. TinyXml did use fgets. But from the XML spec: // 2.11 End-of-Line Handling // @@ -1030,58 +1038,46 @@ bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding ) return false; } - const char* lastPos = buf; - const char* p = buf; + // Process the buffer in place to normalize new lines. (See comment above.) + // Copies from the 'p' to 'q' pointer, where p can advance faster if + // a newline-carriage return is hit. + // + // Wikipedia: + // Systems based on ASCII or a compatible character set use either LF (Line feed, '\n', 0x0A, 10 in decimal) or + // CR (Carriage return, '\r', 0x0D, 13 in decimal) individually, or CR followed by LF (CR+LF, 0x0D 0x0A)... + // * LF: Multics, Unix and Unix-like systems (GNU/Linux, AIX, Xenix, Mac OS X, FreeBSD, etc.), BeOS, Amiga, RISC OS, and others + // * CR+LF: DEC RT-11 and most other early non-Unix, non-IBM OSes, CP/M, MP/M, DOS, OS/2, Microsoft Windows, Symbian OS + // * CR: Commodore 8-bit machines, Apple II family, Mac OS up to version 9 and OS-9 + + const char* p = buf; // the read head + char* q = buf; // the write head + const char CR = 0x0d; + const char LF = 0x0a; buf[length] = 0; while( *p ) { assert( p < (buf+length) ); - if ( *p == 0xa ) { - // Newline character. No special rules for this. Append all the characters - // since the last string, and include the newline. - data.append( lastPos, (p-lastPos+1) ); // append, include the newline - ++p; // move past the newline - lastPos = p; // and point to the new buffer (may be 0) - assert( p <= (buf+length) ); - } - else if ( *p == 0xd ) { - // Carriage return. Append what we have so far, then - // handle moving forward in the buffer. - if ( (p-lastPos) > 0 ) { - data.append( lastPos, p-lastPos ); // do not add the CR - } - data += (char)0xa; // a proper newline - - if ( *(p+1) == 0xa ) { - // Carriage return - new line sequence - p += 2; - lastPos = p; - assert( p <= (buf+length) ); - } - else { - // it was followed by something else...that is presumably characters again. - ++p; - lastPos = p; - assert( p <= (buf+length) ); + assert( q <= (buf+length) ); + assert( q <= p ); + + if ( *p == CR ) { + *q++ = LF; + p++; + if ( *p == LF ) { // check for CR+LF (and skip LF) + p++; } } else { - ++p; + *q++ = *p++; } } - // Handle any left over characters. - if ( p-lastPos ) { - data.append( lastPos, p-lastPos ); - } - delete [] buf; - buf = 0; + assert( q <= (buf+length) ); + *q = 0; - Parse( data.c_str(), 0, encoding ); + Parse( buf, 0, encoding ); - if ( Error() ) - return false; - else - return true; + delete [] buf; + return !Error(); } @@ -1220,7 +1216,7 @@ void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) cons if (value.find ('\"') == TIXML_STRING::npos) { if ( cfile ) { - fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() ); + fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() ); } if ( str ) { (*str) += n; (*str) += "=\""; (*str) += v; (*str) += "\""; @@ -1228,7 +1224,7 @@ void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) cons } else { if ( cfile ) { - fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() ); + fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() ); } if ( str ) { (*str) += n; (*str) += "='"; (*str) += v; (*str) += "'"; @@ -1266,9 +1262,9 @@ void TiXmlAttribute::SetDoubleValue( double _value ) { char buf [256]; #if defined(TIXML_SNPRINTF) - TIXML_SNPRINTF( buf, sizeof(buf), "%lf", _value); + TIXML_SNPRINTF( buf, sizeof(buf), "%g", _value); #else - sprintf (buf, "%lf", _value); + sprintf (buf, "%g", _value); #endif SetValue (buf); } @@ -1284,16 +1280,17 @@ double TiXmlAttribute::DoubleValue() const } -TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::COMMENT ) +TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) { copy.CopyTo( this ); } -void TiXmlComment::operator=( const TiXmlComment& base ) +TiXmlComment& TiXmlComment::operator=( const TiXmlComment& base ) { Clear(); base.CopyTo( this ); + return *this; } @@ -1382,7 +1379,7 @@ TiXmlNode* TiXmlText::Clone() const TiXmlDeclaration::TiXmlDeclaration( const char * _version, const char * _encoding, const char * _standalone ) - : TiXmlNode( TiXmlNode::DECLARATION ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) { version = _version; encoding = _encoding; @@ -1394,7 +1391,7 @@ TiXmlDeclaration::TiXmlDeclaration( const char * _version, TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, const std::string& _encoding, const std::string& _standalone ) - : TiXmlNode( TiXmlNode::DECLARATION ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) { version = _version; encoding = _encoding; @@ -1404,16 +1401,17 @@ TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy ) - : TiXmlNode( TiXmlNode::DECLARATION ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) { copy.CopyTo( this ); } -void TiXmlDeclaration::operator=( const TiXmlDeclaration& copy ) +TiXmlDeclaration& TiXmlDeclaration::operator=( const TiXmlDeclaration& copy ) { Clear(); copy.CopyTo( this ); + return *this; } @@ -1548,9 +1546,9 @@ void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe ) #ifdef TIXML_USE_STL -const TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const +TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const { - for( const TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) + for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) { if ( node->name == name ) return node; @@ -1558,23 +1556,22 @@ const TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const return 0; } -/* -TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) +TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const std::string& _name ) { - for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) - { - if ( node->name == name ) - return node; + TiXmlAttribute* attrib = Find( _name ); + if ( !attrib ) { + attrib = new TiXmlAttribute(); + Add( attrib ); + attrib->SetName( _name ); } - return 0; + return attrib; } -*/ #endif -const TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const +TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const { - for( const TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) + for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) { if ( strcmp( node->name.c_str(), name ) == 0 ) return node; @@ -1582,17 +1579,18 @@ const TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const return 0; } -/* -TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) + +TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const char* _name ) { - for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) - { - if ( strcmp( node->name.c_str(), name ) == 0 ) - return node; + TiXmlAttribute* attrib = Find( _name ); + if ( !attrib ) { + attrib = new TiXmlAttribute(); + Add( attrib ); + attrib->SetName( _name ); } - return 0; + return attrib; } -*/ + #ifdef TIXML_USE_STL std::istream& operator>> (std::istream & in, TiXmlNode & base) diff --git a/depends/tinyxml/tinyxml.h b/depends/tinyxml/tinyxml.h index c6f40cc27a..a3589e5b26 100644 --- a/depends/tinyxml/tinyxml.h +++ b/depends/tinyxml/tinyxml.h @@ -1,6 +1,6 @@ /* www.sourceforge.net/projects/tinyxml -Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com) +Original code by Lee Thomason (www.grinninglizard.com) This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any @@ -63,21 +63,19 @@ distribution. #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) // Microsoft visual studio, version 2005 and higher. #define TIXML_SNPRINTF _snprintf_s - #define TIXML_SNSCANF _snscanf_s #define TIXML_SSCANF sscanf_s #elif defined(_MSC_VER) && (_MSC_VER >= 1200 ) // Microsoft visual studio, version 6 and higher. //#pragma message( "Using _sn* functions." ) #define TIXML_SNPRINTF _snprintf - #define TIXML_SNSCANF _snscanf #define TIXML_SSCANF sscanf #elif defined(__GNUC__) && (__GNUC__ >= 3 ) // GCC version 3 and higher.s //#warning( "Using sn* functions." ) #define TIXML_SNPRINTF snprintf - #define TIXML_SNSCANF snscanf #define TIXML_SSCANF sscanf #else + #define TIXML_SNPRINTF snprintf #define TIXML_SSCANF sscanf #endif #endif @@ -92,8 +90,8 @@ class TiXmlDeclaration; class TiXmlParsingData; const int TIXML_MAJOR_VERSION = 2; -const int TIXML_MINOR_VERSION = 5; -const int TIXML_PATCH_VERSION = 3; +const int TIXML_MINOR_VERSION = 6; +const int TIXML_PATCH_VERSION = 2; /* Internal structure for tracking location of items in the XML file. @@ -109,10 +107,11 @@ struct TiXmlCursor /** + Implements the interface to the "Visitor pattern" (see the Accept() method.) If you call the Accept() method, it requires being passed a TiXmlVisitor class to handle callbacks. For nodes that contain other nodes (Document, Element) you will get called with a VisitEnter/VisitExit pair. Nodes that are always leaves - are simple called with Visit(). + are simply called with Visit(). If you return 'true' from a Visit method, recursive parsing will continue. If you return false, no children of this node or its sibilings will be Visited. @@ -147,7 +146,7 @@ class TiXmlVisitor virtual bool Visit( const TiXmlText& /*text*/ ) { return true; } /// Visit a comment node virtual bool Visit( const TiXmlComment& /*comment*/ ) { return true; } - /// Visit an unknow node + /// Visit an unknown node virtual bool Visit( const TiXmlUnknown& /*unknown*/ ) { return true; } }; @@ -267,7 +266,6 @@ class TiXmlBase TIXML_NO_ERROR = 0, TIXML_ERROR, TIXML_ERROR_OPENING_FILE, - TIXML_ERROR_OUT_OF_MEMORY, TIXML_ERROR_PARSING_ELEMENT, TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, TIXML_ERROR_READING_ELEMENT_VALUE, @@ -288,6 +286,7 @@ class TiXmlBase protected: static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding ); + inline static bool IsWhiteSpace( char c ) { return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); @@ -462,13 +461,13 @@ class TiXmlNode : public TiXmlBase */ enum NodeType { - DOCUMENT, - ELEMENT, - COMMENT, - UNKNOWN, - TEXT, - DECLARATION, - TYPECOUNT + TINYXML_DOCUMENT, + TINYXML_ELEMENT, + TINYXML_COMMENT, + TINYXML_UNKNOWN, + TINYXML_TEXT, + TINYXML_DECLARATION, + TINYXML_TYPECOUNT }; virtual ~TiXmlNode(); @@ -679,8 +678,8 @@ class TiXmlNode : public TiXmlBase #endif /** Query the type (as an enumerated value, above) of this node. - The possible types are: DOCUMENT, ELEMENT, COMMENT, - UNKNOWN, TEXT, and DECLARATION. + The possible types are: TINYXML_DOCUMENT, TINYXML_ELEMENT, TINYXML_COMMENT, + TINYXML_UNKNOWN, TINYXML_TEXT, and TINYXML_DECLARATION. */ int Type() const { return type; } @@ -915,17 +914,14 @@ class TiXmlAttributeSet const TiXmlAttribute* Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; } TiXmlAttribute* Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; } - const TiXmlAttribute* Find( const char* _name ) const; - TiXmlAttribute* Find( const char* _name ) { - return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) ); - } - #ifdef TIXML_USE_STL - const TiXmlAttribute* Find( const std::string& _name ) const; - TiXmlAttribute* Find( const std::string& _name ) { - return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) ); - } + TiXmlAttribute* Find( const char* _name ) const; + TiXmlAttribute* FindOrCreate( const char* _name ); + +# ifdef TIXML_USE_STL + TiXmlAttribute* Find( const std::string& _name ) const; + TiXmlAttribute* FindOrCreate( const std::string& _name ); +# endif - #endif private: //*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element), @@ -954,7 +950,7 @@ class TiXmlElement : public TiXmlNode TiXmlElement( const TiXmlElement& ); - void operator=( const TiXmlElement& base ); + TiXmlElement& operator=( const TiXmlElement& base ); virtual ~TiXmlElement(); @@ -987,6 +983,13 @@ class TiXmlElement : public TiXmlNode does not exist, then TIXML_NO_ATTRIBUTE is returned. */ int QueryIntAttribute( const char* name, int* _value ) const; + /// QueryUnsignedAttribute examines the attribute - see QueryIntAttribute(). + int QueryUnsignedAttribute( const char* name, unsigned* _value ) const; + /** QueryBoolAttribute examines the attribute - see QueryIntAttribute(). + Note that '1', 'true', or 'yes' are considered true, while '0', 'false' + and 'no' are considered false. + */ + int QueryBoolAttribute( const char* name, bool* _value ) const; /// QueryDoubleAttribute examines the attribute - see QueryIntAttribute(). int QueryDoubleAttribute( const char* name, double* _value ) const; /// QueryFloatAttribute examines the attribute - see QueryIntAttribute(). @@ -1000,11 +1003,21 @@ class TiXmlElement : public TiXmlNode } #ifdef TIXML_USE_STL + /// QueryStringAttribute examines the attribute - see QueryIntAttribute(). + int QueryStringAttribute( const char* name, std::string* _value ) const { + const char* cstr = Attribute( name ); + if ( cstr ) { + *_value = std::string( cstr ); + return TIXML_SUCCESS; + } + return TIXML_NO_ATTRIBUTE; + } + /** Template form of the attribute query which will try to read the attribute into the specified type. Very easy, very powerful, but be careful to make sure to call this with the correct type. - NOTE: This method doesn't work correctly for 'string' types. + NOTE: This method doesn't work correctly for 'string' types that contain spaces. @return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE */ @@ -1020,13 +1033,8 @@ class TiXmlElement : public TiXmlNode return TIXML_SUCCESS; return TIXML_WRONG_TYPE; } - /* - This is - in theory - a bug fix for "QueryValueAtribute returns truncated std::string" - but template specialization is hard to get working cross-compiler. Leaving the bug for now. - - // The above will fail for std::string because the space character is used as a seperator. - // Specialize for strings. Bug [ 1695429 ] QueryValueAtribute returns truncated std::string - template<> int QueryValueAttribute( const std::string& name, std::string* outValue ) const + + int QueryValueAttribute( const std::string& name, std::string* outValue ) const { const TiXmlAttribute* node = attributeSet.Find( name ); if ( !node ) @@ -1034,7 +1042,6 @@ class TiXmlElement : public TiXmlNode *outValue = node->ValueStr(); return TIXML_SUCCESS; } - */ #endif /** Sets an attribute of name to a given value. The attribute @@ -1053,6 +1060,8 @@ class TiXmlElement : public TiXmlNode void SetAttribute( const std::string& name, const std::string& _value ); ///< STL std::string form. void SetAttribute( const std::string& name, int _value ); + ///< STL std::string form. + void SetDoubleAttribute( const std::string& name, double value ); #endif /** Sets an attribute of name to a given value. The attribute @@ -1144,7 +1153,6 @@ class TiXmlElement : public TiXmlNode const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding ); private: - TiXmlAttributeSet attributeSet; }; @@ -1155,13 +1163,13 @@ class TiXmlComment : public TiXmlNode { public: /// Constructs an empty comment. - TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {} + TiXmlComment() : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {} /// Construct a comment from text. - TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::COMMENT ) { + TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) { SetValue( _value ); } TiXmlComment( const TiXmlComment& ); - void operator=( const TiXmlComment& base ); + TiXmlComment& operator=( const TiXmlComment& base ); virtual ~TiXmlComment() {} @@ -1175,8 +1183,8 @@ class TiXmlComment : public TiXmlNode */ virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); - virtual const TiXmlComment* ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - virtual TiXmlComment* ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual const TiXmlComment* ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlComment* ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. /** Walk the XML tree visiting this node and all of its children. */ @@ -1209,7 +1217,7 @@ class TiXmlText : public TiXmlNode normal, encoded text. If you want it be output as a CDATA text element, set the parameter _cdata to 'true' */ - TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT) + TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT) { SetValue( initValue ); cdata = false; @@ -1218,15 +1226,15 @@ class TiXmlText : public TiXmlNode #ifdef TIXML_USE_STL /// Constructor. - TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT) + TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT) { SetValue( initValue ); cdata = false; } #endif - TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT ) { copy.CopyTo( this ); } - void operator=( const TiXmlText& base ) { base.CopyTo( this ); } + TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TINYXML_TEXT ) { copy.CopyTo( this ); } + TiXmlText& operator=( const TiXmlText& base ) { base.CopyTo( this ); return *this; } // Write this text object to a FILE stream. virtual void Print( FILE* cfile, int depth ) const; @@ -1278,7 +1286,7 @@ class TiXmlDeclaration : public TiXmlNode { public: /// Construct an empty declaration. - TiXmlDeclaration() : TiXmlNode( TiXmlNode::DECLARATION ) {} + TiXmlDeclaration() : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) {} #ifdef TIXML_USE_STL /// Constructor. @@ -1293,7 +1301,7 @@ class TiXmlDeclaration : public TiXmlNode const char* _standalone ); TiXmlDeclaration( const TiXmlDeclaration& copy ); - void operator=( const TiXmlDeclaration& copy ); + TiXmlDeclaration& operator=( const TiXmlDeclaration& copy ); virtual ~TiXmlDeclaration() {} @@ -1346,11 +1354,11 @@ class TiXmlDeclaration : public TiXmlNode class TiXmlUnknown : public TiXmlNode { public: - TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN ) {} + TiXmlUnknown() : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN ) {} virtual ~TiXmlUnknown() {} - TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN ) { copy.CopyTo( this ); } - void operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); } + TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN ) { copy.CopyTo( this ); } + TiXmlUnknown& operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); return *this; } /// Creates a copy of this Unknown and returns it. virtual TiXmlNode* Clone() const; @@ -1359,8 +1367,8 @@ class TiXmlUnknown : public TiXmlNode virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); - virtual const TiXmlUnknown* ToUnknown() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. - virtual TiXmlUnknown* ToUnknown() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual const TiXmlUnknown* ToUnknown() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type. + virtual TiXmlUnknown* ToUnknown() { return this; } ///< Cast to a more defined type. Will return null not of the requested type. /** Walk the XML tree visiting this node and all of its children. */ @@ -1396,7 +1404,7 @@ class TiXmlDocument : public TiXmlNode #endif TiXmlDocument( const TiXmlDocument& copy ); - void operator=( const TiXmlDocument& copy ); + TiXmlDocument& operator=( const TiXmlDocument& copy ); virtual ~TiXmlDocument() {} @@ -1423,14 +1431,10 @@ class TiXmlDocument : public TiXmlNode #ifdef TIXML_USE_STL bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ) ///< STL std::string version. { -// StringToBuffer f( filename ); -// return ( f.buffer && LoadFile( f.buffer, encoding )); return LoadFile( filename.c_str(), encoding ); } bool SaveFile( const std::string& filename ) const ///< STL std::string version. { -// StringToBuffer f( filename ); -// return ( f.buffer && SaveFile( f.buffer )); return SaveFile( filename.c_str() ); } #endif @@ -1638,7 +1642,7 @@ class TiXmlHandle TiXmlHandle( TiXmlNode* _node ) { this->node = _node; } /// Copy constructor TiXmlHandle( const TiXmlHandle& ref ) { this->node = ref.node; } - TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; } + TiXmlHandle operator=( const TiXmlHandle& ref ) { if ( &ref != this ) this->node = ref.node; return *this; } /// Return a handle to the first child node. TiXmlHandle FirstChild() const; @@ -1799,4 +1803,3 @@ class TiXmlPrinter : public TiXmlVisitor #endif #endif - diff --git a/depends/tinyxml/tinyxmlerror.cpp b/depends/tinyxml/tinyxmlerror.cpp index d24f63b2e5..538c21d0bd 100644 --- a/depends/tinyxml/tinyxmlerror.cpp +++ b/depends/tinyxml/tinyxmlerror.cpp @@ -31,12 +31,11 @@ distribution. // It also cleans up the code a bit. // -const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] = +const char* TiXmlBase::errorString[ TiXmlBase::TIXML_ERROR_STRING_COUNT ] = { "No error", "Error", "Failed to open file", - "Memory allocation failed.", "Error parsing Element.", "Failed to read Element name", "Error reading Element value.", diff --git a/depends/tinyxml/tinyxmlparser.cpp b/depends/tinyxml/tinyxmlparser.cpp index 5793f05286..81b7eae96b 100644 --- a/depends/tinyxml/tinyxmlparser.cpp +++ b/depends/tinyxml/tinyxmlparser.cpp @@ -1,6 +1,6 @@ /* www.sourceforge.net/projects/tinyxml -Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) +Original code by Lee Thomason (www.grinninglizard.com) This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any @@ -40,7 +40,7 @@ distribution. // Note tha "PutString" hardcodes the same list. This // is less flexible than it appears. Changing the entries // or order will break putstring. -TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] = +TiXmlBase::Entity TiXmlBase::entity[ TiXmlBase::NUM_ENTITY ] = { { "&", 5, '&' }, { "<", 4, '<' }, @@ -174,7 +174,7 @@ class TiXmlParsingData public: void Stamp( const char* now, TiXmlEncoding encoding ); - const TiXmlCursor& Cursor() { return cursor; } + const TiXmlCursor& Cursor() const { return cursor; } private: // Only used by the document! @@ -346,7 +346,7 @@ const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding ) continue; } - if ( IsWhiteSpace( *p ) || *p == '\n' || *p =='\r' ) // Still using old rules for white space. + if ( IsWhiteSpace( *p ) ) // Still using old rules for white space. ++p; else break; @@ -354,7 +354,7 @@ const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding ) } else { - while ( (*p && IsWhiteSpace( *p )) || *p == '\n' || *p =='\r' ) + while ( *p && IsWhiteSpace( *p ) ) ++p; } @@ -631,9 +631,9 @@ const char* TiXmlBase::ReadText( const char* p, } } } - if ( p ) + if ( p && *p ) p += strlen( endTag ); - return p; + return ( p && *p ) ? p : 0; } #ifdef TIXML_USE_STL @@ -825,7 +825,6 @@ TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding ) return 0; } - TiXmlDocument* doc = GetDocument(); p = SkipWhiteSpace( p, encoding ); if ( !p || !*p ) @@ -896,11 +895,6 @@ TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding ) // Set the parent, so it can report errors returnNode->parent = this; } - else - { - if ( doc ) - doc->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN ); - } return returnNode; } @@ -1083,7 +1077,6 @@ const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc TIXML_STRING endTag (""; // Check for and read attributes. Also look for an empty // tag or an end tag. @@ -1122,10 +1115,20 @@ const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc } // We should find the end tag now + // note that: + // and + // + // are both valid end tags. if ( StringEqual( p, endTag.c_str(), false, encoding ) ) { p += endTag.length(); - return p; + p = SkipWhiteSpace( p, encoding ); + if ( p && *p && *p == '>' ) { + ++p; + return p; + } + if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding ); + return 0; } else { @@ -1139,7 +1142,6 @@ const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc TiXmlAttribute* attrib = new TiXmlAttribute(); if ( !attrib ) { - if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, pErr, data, encoding ); return 0; } @@ -1162,7 +1164,7 @@ const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc #endif if ( node ) { - node->SetValue( attrib->Value() ); + if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding ); delete attrib; return 0; } @@ -1191,8 +1193,7 @@ const char* TiXmlElement::ReadValue( const char* p, TiXmlParsingData* data, TiXm if ( !textNode ) { - if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, encoding ); - return 0; + return 0; } if ( TiXmlBase::IsWhiteSpaceCondensed() ) @@ -1297,9 +1298,10 @@ const char* TiXmlUnknown::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc if ( !p ) { - if ( document ) document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding ); + if ( document ) + document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding ); } - if ( *p == '>' ) + if ( p && *p == '>' ) return p+1; return p; } @@ -1349,7 +1351,8 @@ const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc if ( !StringEqual( p, startTag, false, encoding ) ) { - document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding ); + if ( document ) + document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding ); return 0; } p += strlen( startTag ); @@ -1379,7 +1382,7 @@ const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data, TiXmlEnc value.append( p, 1 ); ++p; } - if ( p ) + if ( p && *p ) p += strlen( endTag ); return p; @@ -1391,10 +1394,6 @@ const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlE p = SkipWhiteSpace( p, encoding ); if ( !p || !*p ) return 0; -// int tabsize = 4; -// if ( document ) -// tabsize = document->TabSize(); - if ( data ) { data->Stamp( p, encoding ); @@ -1446,7 +1445,7 @@ const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlE // its best, even without them. value = ""; while ( p && *p // existence - && !IsWhiteSpace( *p ) && *p != '\n' && *p != '\r' // whitespace + && !IsWhiteSpace( *p ) // whitespace && *p != '/' && *p != '>' ) // tag end { if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) { @@ -1515,7 +1514,8 @@ const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncodi if ( !StringEqual( p, startTag, false, encoding ) ) { - document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding ); + if ( document ) + document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding ); return 0; } p += strlen( startTag ); @@ -1539,7 +1539,7 @@ const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncodi const char* end = "<"; p = ReadText( p, &value, ignoreWhite, end, false, encoding ); - if ( p ) + if ( p && *p ) return p-1; // don't truncate the '<' return 0; } diff --git a/depends/tthread/CMakeLists.txt b/depends/tthread/CMakeLists.txt deleted file mode 100644 index fa1a578993..0000000000 --- a/depends/tthread/CMakeLists.txt +++ /dev/null @@ -1,6 +0,0 @@ -PROJECT(dfhack-tinythread) -ADD_LIBRARY(dfhack-tinythread STATIC EXCLUDE_FROM_ALL tinythread.cpp tinythread.h fast_mutex.h) -if(UNIX) - target_link_libraries(dfhack-tinythread pthread) -endif() -IDE_FOLDER(dfhack-tinythread "Depends") \ No newline at end of file diff --git a/depends/tthread/fast_mutex.h b/depends/tthread/fast_mutex.h deleted file mode 100644 index 6627408e41..0000000000 --- a/depends/tthread/fast_mutex.h +++ /dev/null @@ -1,249 +0,0 @@ -/* -*- mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- -Copyright (c) 2010-2012 Marcus Geelnard - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any damages -arising from the use of this software. - -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it -freely, subject to the following restrictions: - - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. - - 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - - 3. This notice may not be removed or altered from any source - distribution. -*/ - -#ifndef _FAST_MUTEX_H_ -#define _FAST_MUTEX_H_ - -/// @file - -// Which platform are we on? -#if !defined(_TTHREAD_PLATFORM_DEFINED_) - #if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__) - #define _TTHREAD_WIN32_ - #else - #define _TTHREAD_POSIX_ - #endif - #define _TTHREAD_PLATFORM_DEFINED_ -#endif - -// Check if we can support the assembly language level implementation (otherwise -// revert to the system API) -#if (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))) || \ - (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))) || \ - (defined(__GNUC__) && (defined(__ppc__))) - #define _FAST_MUTEX_ASM_ -#else - #define _FAST_MUTEX_SYS_ -#endif - -#if defined(_TTHREAD_WIN32_) - #define NOMINMAX - #ifndef WIN32_LEAN_AND_MEAN - #define WIN32_LEAN_AND_MEAN - #define __UNDEF_LEAN_AND_MEAN - #endif - #include - #ifdef __UNDEF_LEAN_AND_MEAN - #undef WIN32_LEAN_AND_MEAN - #undef __UNDEF_LEAN_AND_MEAN - #endif -#else - #ifdef _FAST_MUTEX_ASM_ - #include - #else - #include - #endif -#endif - -namespace tthread { - -/// Fast mutex class. -/// This is a mutual exclusion object for synchronizing access to shared -/// memory areas for several threads. It is similar to the tthread::mutex class, -/// but instead of using system level functions, it is implemented as an atomic -/// spin lock with very low CPU overhead. -/// -/// The \c fast_mutex class is NOT compatible with the \c condition_variable -/// class (however, it IS compatible with the \c lock_guard class). It should -/// also be noted that the \c fast_mutex class typically does not provide -/// as accurate thread scheduling as a the standard \c mutex class does. -/// -/// Because of the limitations of the class, it should only be used in -/// situations where the mutex needs to be locked/unlocked very frequently. -/// -/// @note The "fast" version of this class relies on inline assembler language, -/// which is currently only supported for 32/64-bit Intel x86/AMD64 and -/// PowerPC architectures on a limited number of compilers (GNU g++ and MS -/// Visual C++). -/// For other architectures/compilers, system functions are used instead. -class fast_mutex { - public: - /// Constructor. -#if defined(_FAST_MUTEX_ASM_) - fast_mutex() : mLock(0) {} -#else - fast_mutex() - { - #if defined(_TTHREAD_WIN32_) - InitializeCriticalSection(&mHandle); - #elif defined(_TTHREAD_POSIX_) - pthread_mutex_init(&mHandle, NULL); - #endif - } -#endif - -#if !defined(_FAST_MUTEX_ASM_) - /// Destructor. - ~fast_mutex() - { - #if defined(_TTHREAD_WIN32_) - DeleteCriticalSection(&mHandle); - #elif defined(_TTHREAD_POSIX_) - pthread_mutex_destroy(&mHandle); - #endif - } -#endif - - /// Lock the mutex. - /// The method will block the calling thread until a lock on the mutex can - /// be obtained. The mutex remains locked until \c unlock() is called. - /// @see lock_guard - inline void lock() - { -#if defined(_FAST_MUTEX_ASM_) - bool gotLock; - do { - gotLock = try_lock(); - if(!gotLock) - { - #if defined(_TTHREAD_WIN32_) - Sleep(0); - #elif defined(_TTHREAD_POSIX_) - sched_yield(); - #endif - } - } while(!gotLock); -#else - #if defined(_TTHREAD_WIN32_) - EnterCriticalSection(&mHandle); - #elif defined(_TTHREAD_POSIX_) - pthread_mutex_lock(&mHandle); - #endif -#endif - } - - /// Try to lock the mutex. - /// The method will try to lock the mutex. If it fails, the function will - /// return immediately (non-blocking). - /// @return \c true if the lock was acquired, or \c false if the lock could - /// not be acquired. - inline bool try_lock() - { -#if defined(_FAST_MUTEX_ASM_) - int oldLock; - #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) - asm volatile ( - "movl $1,%%eax\n\t" - "xchg %%eax,%0\n\t" - "movl %%eax,%1\n\t" - : "=m" (mLock), "=m" (oldLock) - : - : "%eax", "memory" - ); - #elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64)) - int *ptrLock = &mLock; - __asm { - mov eax,1 - mov ecx,ptrLock - xchg eax,[ecx] - mov oldLock,eax - } - #elif defined(__GNUC__) && (defined(__ppc__)) - int newLock = 1; - asm volatile ( - "\n1:\n\t" - "lwarx %0,0,%1\n\t" - "cmpwi 0,%0,0\n\t" - "bne- 2f\n\t" - "stwcx. %2,0,%1\n\t" - "bne- 1b\n\t" - "isync\n" - "2:\n\t" - : "=&r" (oldLock) - : "r" (&mLock), "r" (newLock) - : "cr0", "memory" - ); - #endif - return (oldLock == 0); -#else - #if defined(_TTHREAD_WIN32_) - return TryEnterCriticalSection(&mHandle) ? true : false; - #elif defined(_TTHREAD_POSIX_) - return (pthread_mutex_trylock(&mHandle) == 0) ? true : false; - #endif -#endif - } - - /// Unlock the mutex. - /// If any threads are waiting for the lock on this mutex, one of them will - /// be unblocked. - inline void unlock() - { -#if defined(_FAST_MUTEX_ASM_) - #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) - asm volatile ( - "movl $0,%%eax\n\t" - "xchg %%eax,%0\n\t" - : "=m" (mLock) - : - : "%eax", "memory" - ); - #elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64)) - int *ptrLock = &mLock; - __asm { - mov eax,0 - mov ecx,ptrLock - xchg eax,[ecx] - } - #elif defined(__GNUC__) && (defined(__ppc__)) - asm volatile ( - "sync\n\t" // Replace with lwsync where possible? - : : : "memory" - ); - mLock = 0; - #endif -#else - #if defined(_TTHREAD_WIN32_) - LeaveCriticalSection(&mHandle); - #elif defined(_TTHREAD_POSIX_) - pthread_mutex_unlock(&mHandle); - #endif -#endif - } - - private: -#if defined(_FAST_MUTEX_ASM_) - int mLock; -#else - #if defined(_TTHREAD_WIN32_) - CRITICAL_SECTION mHandle; - #elif defined(_TTHREAD_POSIX_) - pthread_mutex_t mHandle; - #endif -#endif -}; - -} - -#endif // _FAST_MUTEX_H_ - diff --git a/depends/tthread/tinythread.cpp b/depends/tthread/tinythread.cpp deleted file mode 100644 index 176bc2ac88..0000000000 --- a/depends/tthread/tinythread.cpp +++ /dev/null @@ -1,313 +0,0 @@ -/* -*- mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- -Copyright (c) 2010-2012 Marcus Geelnard - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any damages -arising from the use of this software. - -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it -freely, subject to the following restrictions: - - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. - - 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - - 3. This notice may not be removed or altered from any source - distribution. -*/ - -#include -#include "tinythread.h" - -#if defined(_TTHREAD_POSIX_) - #include - #include -#elif defined(_TTHREAD_WIN32_) - #include -#endif - - -namespace tthread { - -//------------------------------------------------------------------------------ -// condition_variable -//------------------------------------------------------------------------------ -// NOTE 1: The Win32 implementation of the condition_variable class is based on -// the corresponding implementation in GLFW, which in turn is based on a -// description by Douglas C. Schmidt and Irfan Pyarali: -// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html -// -// NOTE 2: Windows Vista actually has native support for condition variables -// (InitializeConditionVariable, WakeConditionVariable, etc), but we want to -// be portable with pre-Vista Windows versions, so TinyThread++ does not use -// Vista condition variables. -//------------------------------------------------------------------------------ - -#if defined(_TTHREAD_WIN32_) - #define _CONDITION_EVENT_ONE 0 - #define _CONDITION_EVENT_ALL 1 -#endif - -#if defined(_TTHREAD_WIN32_) -condition_variable::condition_variable() : mWaitersCount(0) -{ - mEvents[_CONDITION_EVENT_ONE] = CreateEvent(NULL, FALSE, FALSE, NULL); - mEvents[_CONDITION_EVENT_ALL] = CreateEvent(NULL, TRUE, FALSE, NULL); - InitializeCriticalSection(&mWaitersCountLock); -} -#endif - -#if defined(_TTHREAD_WIN32_) -condition_variable::~condition_variable() -{ - CloseHandle(mEvents[_CONDITION_EVENT_ONE]); - CloseHandle(mEvents[_CONDITION_EVENT_ALL]); - DeleteCriticalSection(&mWaitersCountLock); -} -#endif - -#if defined(_TTHREAD_WIN32_) -void condition_variable::_wait() -{ - // Wait for either event to become signaled due to notify_one() or - // notify_all() being called - int result = WaitForMultipleObjects(2, mEvents, FALSE, INFINITE); - - // Check if we are the last waiter - EnterCriticalSection(&mWaitersCountLock); - -- mWaitersCount; - bool lastWaiter = (result == (WAIT_OBJECT_0 + _CONDITION_EVENT_ALL)) && - (mWaitersCount == 0); - LeaveCriticalSection(&mWaitersCountLock); - - // If we are the last waiter to be notified to stop waiting, reset the event - if(lastWaiter) - ResetEvent(mEvents[_CONDITION_EVENT_ALL]); -} -#endif - -#if defined(_TTHREAD_WIN32_) -void condition_variable::notify_one() -{ - // Are there any waiters? - EnterCriticalSection(&mWaitersCountLock); - bool haveWaiters = (mWaitersCount > 0); - LeaveCriticalSection(&mWaitersCountLock); - - // If we have any waiting threads, send them a signal - if(haveWaiters) - SetEvent(mEvents[_CONDITION_EVENT_ONE]); -} -#endif - -#if defined(_TTHREAD_WIN32_) -void condition_variable::notify_all() -{ - // Are there any waiters? - EnterCriticalSection(&mWaitersCountLock); - bool haveWaiters = (mWaitersCount > 0); - LeaveCriticalSection(&mWaitersCountLock); - - // If we have any waiting threads, send them a signal - if(haveWaiters) - SetEvent(mEvents[_CONDITION_EVENT_ALL]); -} -#endif - - -//------------------------------------------------------------------------------ -// POSIX pthread_t to unique thread::id mapping logic. -// Note: Here we use a global thread safe std::map to convert instances of -// pthread_t to small thread identifier numbers (unique within one process). -// This method should be portable across different POSIX implementations. -//------------------------------------------------------------------------------ - -#if defined(_TTHREAD_POSIX_) -static thread::id _pthread_t_to_ID(const pthread_t &aHandle) -{ - static mutex idMapLock; - static std::map idMap; - static unsigned long int idCount(1); - - lock_guard guard(idMapLock); - if(idMap.find(aHandle) == idMap.end()) - idMap[aHandle] = idCount ++; - return thread::id(idMap[aHandle]); -} -#endif // _TTHREAD_POSIX_ - - -//------------------------------------------------------------------------------ -// thread -//------------------------------------------------------------------------------ - -/// Information to pass to the new thread (what to run). -struct _thread_start_info { - void (*mFunction)(void *); ///< Pointer to the function to be executed. - void * mArg; ///< Function argument for the thread function. - thread * mThread; ///< Pointer to the thread object. -}; - -// Thread wrapper function. -#if defined(_TTHREAD_WIN32_) -unsigned WINAPI thread::wrapper_function(void * aArg) -#elif defined(_TTHREAD_POSIX_) -void * thread::wrapper_function(void * aArg) -#endif -{ - // Get thread startup information - _thread_start_info * ti = (_thread_start_info *) aArg; - - try - { - // Call the actual client thread function - ti->mFunction(ti->mArg); - } - catch(...) - { - // Uncaught exceptions will terminate the application (default behavior - // according to C++11) - std::terminate(); - } - -#if 0 - // DFHack fix: this code prevents join from freeing thread resources. - - // The thread is no longer executing - lock_guard guard(ti->mThread->mDataMutex); - ti->mThread->mNotAThread = true; -#endif - - // The thread is responsible for freeing the startup information - delete ti; - - return 0; -} - -thread::thread(void (*aFunction)(void *), void * aArg) -{ - // Serialize access to this thread structure - lock_guard guard(mDataMutex); - - // Fill out the thread startup information (passed to the thread wrapper, - // which will eventually free it) - _thread_start_info * ti = new _thread_start_info; - ti->mFunction = aFunction; - ti->mArg = aArg; - ti->mThread = this; - - // The thread is now alive - mNotAThread = false; - - // Create the thread -#if defined(_TTHREAD_WIN32_) - mHandle = (HANDLE) _beginthreadex(0, 0, wrapper_function, (void *) ti, 0, &mWin32ThreadID); -#elif defined(_TTHREAD_POSIX_) - if(pthread_create(&mHandle, NULL, wrapper_function, (void *) ti) != 0) - mHandle = 0; -#endif - - // Did we fail to create the thread? - if(!mHandle) - { - mNotAThread = true; - delete ti; - } -} - -thread::~thread() -{ - if(joinable()) - std::terminate(); -} - -void thread::join() -{ - if(joinable()) - { -#if defined(_TTHREAD_WIN32_) - WaitForSingleObject(mHandle, INFINITE); - CloseHandle(mHandle); -#elif defined(_TTHREAD_POSIX_) - pthread_join(mHandle, NULL); -#endif - -#if 1 - // DFHack patch: moved here from the wrapper function - lock_guard guard(mDataMutex); - mNotAThread = true; -#endif - } -} - -bool thread::joinable() const -{ - mDataMutex.lock(); - bool result = !mNotAThread; - mDataMutex.unlock(); - return result; -} - -void thread::detach() -{ - mDataMutex.lock(); - if(!mNotAThread) - { -#if defined(_TTHREAD_WIN32_) - CloseHandle(mHandle); -#elif defined(_TTHREAD_POSIX_) - pthread_detach(mHandle); -#endif - mNotAThread = true; - } - mDataMutex.unlock(); -} - -thread::id thread::get_id() const -{ - if(!joinable()) - return id(); -#if defined(_TTHREAD_WIN32_) - return id((unsigned long int) mWin32ThreadID); -#elif defined(_TTHREAD_POSIX_) - return _pthread_t_to_ID(mHandle); -#endif -} - -unsigned thread::hardware_concurrency() -{ -#if defined(_TTHREAD_WIN32_) - SYSTEM_INFO si; - GetSystemInfo(&si); - return (int) si.dwNumberOfProcessors; -#elif defined(_SC_NPROCESSORS_ONLN) - return (int) sysconf(_SC_NPROCESSORS_ONLN); -#elif defined(_SC_NPROC_ONLN) - return (int) sysconf(_SC_NPROC_ONLN); -#else - // The standard requires this function to return zero if the number of - // hardware cores could not be determined. - return 0; -#endif -} - - -//------------------------------------------------------------------------------ -// this_thread -//------------------------------------------------------------------------------ - -thread::id this_thread::get_id() -{ -#if defined(_TTHREAD_WIN32_) - return thread::id((unsigned long int) GetCurrentThreadId()); -#elif defined(_TTHREAD_POSIX_) - return _pthread_t_to_ID(pthread_self()); -#endif -} - -} diff --git a/depends/tthread/tinythread.h b/depends/tthread/tinythread.h deleted file mode 100644 index d575bae33c..0000000000 --- a/depends/tthread/tinythread.h +++ /dev/null @@ -1,715 +0,0 @@ -/* -*- mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- -Copyright (c) 2010-2012 Marcus Geelnard - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any damages -arising from the use of this software. - -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it -freely, subject to the following restrictions: - - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. - - 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - - 3. This notice may not be removed or altered from any source - distribution. -*/ - -#ifndef _TINYTHREAD_H_ -#define _TINYTHREAD_H_ - -/// @file -/// @mainpage TinyThread++ API Reference -/// -/// @section intro_sec Introduction -/// TinyThread++ is a minimal, portable implementation of basic threading -/// classes for C++. -/// -/// They closely mimic the functionality and naming of the C++11 standard, and -/// should be easily replaceable with the corresponding std:: variants. -/// -/// @section port_sec Portability -/// The Win32 variant uses the native Win32 API for implementing the thread -/// classes, while for other systems, the POSIX threads API (pthread) is used. -/// -/// @section class_sec Classes -/// In order to mimic the threading API of the C++11 standard, subsets of -/// several classes are provided. The fundamental classes are: -/// @li tthread::thread -/// @li tthread::mutex -/// @li tthread::recursive_mutex -/// @li tthread::condition_variable -/// @li tthread::lock_guard -/// @li tthread::fast_mutex -/// -/// @section misc_sec Miscellaneous -/// The following special keywords are available: #thread_local. -/// -/// For more detailed information (including additional classes), browse the -/// different sections of this documentation. A good place to start is: -/// tinythread.h. - -// Which platform are we on? -#if !defined(_TTHREAD_PLATFORM_DEFINED_) - #if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__) - #define _TTHREAD_WIN32_ - #else - #define _TTHREAD_POSIX_ - #endif - #define _TTHREAD_PLATFORM_DEFINED_ -#endif - -// Platform specific includes -#if defined(_TTHREAD_WIN32_) - #define NOMINMAX - #ifndef WIN32_LEAN_AND_MEAN - #define WIN32_LEAN_AND_MEAN - #define __UNDEF_LEAN_AND_MEAN - #endif - #include - #ifdef __UNDEF_LEAN_AND_MEAN - #undef WIN32_LEAN_AND_MEAN - #undef __UNDEF_LEAN_AND_MEAN - #endif -#else - #include - #include - #include - #include -#endif - -// Generic includes -#include - -/// TinyThread++ version (major number). -#define TINYTHREAD_VERSION_MAJOR 1 -/// TinyThread++ version (minor number). -#define TINYTHREAD_VERSION_MINOR 1 -/// TinyThread++ version (full version). -#define TINYTHREAD_VERSION (TINYTHREAD_VERSION_MAJOR * 100 + TINYTHREAD_VERSION_MINOR) - -// Do we have a fully featured C++11 compiler? -#if (__cplusplus > 199711L) || (defined(__STDCXX_VERSION__) && (__STDCXX_VERSION__ >= 201001L)) - #define _TTHREAD_CPP11_ -#endif - -// ...at least partial C++11? -#if defined(_TTHREAD_CPP11_) || defined(__GXX_EXPERIMENTAL_CXX0X__) || defined(__GXX_EXPERIMENTAL_CPP0X__) - #define _TTHREAD_CPP11_PARTIAL_ -#endif - -// Macro for disabling assignments of objects. -#ifdef _TTHREAD_CPP11_PARTIAL_ - #define _TTHREAD_DISABLE_ASSIGNMENT(name) \ - name(const name&) = delete; \ - name& operator=(const name&) = delete; -#else - #define _TTHREAD_DISABLE_ASSIGNMENT(name) \ - name(const name&); \ - name& operator=(const name&); -#endif - -/// @def thread_local -/// Thread local storage keyword. -/// A variable that is declared with the @c thread_local keyword makes the -/// value of the variable local to each thread (known as thread-local storage, -/// or TLS). Example usage: -/// @code -/// // This variable is local to each thread. -/// thread_local int variable; -/// @endcode -/// @note The @c thread_local keyword is a macro that maps to the corresponding -/// compiler directive (e.g. @c __declspec(thread)). While the C++11 standard -/// allows for non-trivial types (e.g. classes with constructors and -/// destructors) to be declared with the @c thread_local keyword, most pre-C++11 -/// compilers only allow for trivial types (e.g. @c int). So, to guarantee -/// portable code, only use trivial types for thread local storage. -/// @note This directive is currently not supported on Mac OS X (it will give -/// a compiler error), since compile-time TLS is not supported in the Mac OS X -/// executable format. Also, some older versions of MinGW (before GCC 4.x) do -/// not support this directive. -/// @hideinitializer - -#if !defined(_TTHREAD_CPP11_) && !defined(thread_local) - #if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_CC) || defined(__IBMCPP__) - #define thread_local __thread - #else - #define thread_local __declspec(thread) - #endif -#endif - - -/// Main name space for TinyThread++. -/// This namespace is more or less equivalent to the @c std namespace for the -/// C++11 thread classes. For instance, the tthread::mutex class corresponds to -/// the std::mutex class. -namespace tthread { - -/// Mutex class. -/// This is a mutual exclusion object for synchronizing access to shared -/// memory areas for several threads. The mutex is non-recursive (i.e. a -/// program may deadlock if the thread that owns a mutex object calls lock() -/// on that object). -/// @see recursive_mutex -class mutex { - public: - /// Constructor. - mutex() -#if defined(_TTHREAD_WIN32_) - : mAlreadyLocked(false) -#endif - { -#if defined(_TTHREAD_WIN32_) - InitializeCriticalSection(&mHandle); -#else - pthread_mutex_init(&mHandle, NULL); -#endif - } - - /// Destructor. - ~mutex() - { -#if defined(_TTHREAD_WIN32_) - DeleteCriticalSection(&mHandle); -#else - pthread_mutex_destroy(&mHandle); -#endif - } - - /// Lock the mutex. - /// The method will block the calling thread until a lock on the mutex can - /// be obtained. The mutex remains locked until @c unlock() is called. - /// @see lock_guard - inline void lock() - { -#if defined(_TTHREAD_WIN32_) - EnterCriticalSection(&mHandle); - while(mAlreadyLocked) Sleep(1000); // Simulate deadlock... - mAlreadyLocked = true; -#else - pthread_mutex_lock(&mHandle); -#endif - } - - /// Try to lock the mutex. - /// The method will try to lock the mutex. If it fails, the function will - /// return immediately (non-blocking). - /// @return @c true if the lock was acquired, or @c false if the lock could - /// not be acquired. - inline bool try_lock() - { -#if defined(_TTHREAD_WIN32_) - bool ret = (TryEnterCriticalSection(&mHandle) ? true : false); - if(ret && mAlreadyLocked) - { - LeaveCriticalSection(&mHandle); - ret = false; - } - return ret; -#else - return (pthread_mutex_trylock(&mHandle) == 0) ? true : false; -#endif - } - - /// Unlock the mutex. - /// If any threads are waiting for the lock on this mutex, one of them will - /// be unblocked. - inline void unlock() - { -#if defined(_TTHREAD_WIN32_) - mAlreadyLocked = false; - LeaveCriticalSection(&mHandle); -#else - pthread_mutex_unlock(&mHandle); -#endif - } - - _TTHREAD_DISABLE_ASSIGNMENT(mutex) - - private: -#if defined(_TTHREAD_WIN32_) - CRITICAL_SECTION mHandle; - bool mAlreadyLocked; -#else - pthread_mutex_t mHandle; -#endif - - friend class condition_variable; -}; - -/// Recursive mutex class. -/// This is a mutual exclusion object for synchronizing access to shared -/// memory areas for several threads. The mutex is recursive (i.e. a thread -/// may lock the mutex several times, as long as it unlocks the mutex the same -/// number of times). -/// @see mutex -class recursive_mutex { - public: - /// Constructor. - recursive_mutex() - { -#if defined(_TTHREAD_WIN32_) - InitializeCriticalSection(&mHandle); -#else - pthread_mutexattr_t attr; - pthread_mutexattr_init(&attr); - pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); - pthread_mutex_init(&mHandle, &attr); -#endif - } - - /// Destructor. - ~recursive_mutex() - { -#if defined(_TTHREAD_WIN32_) - DeleteCriticalSection(&mHandle); -#else - pthread_mutex_destroy(&mHandle); -#endif - } - - /// Lock the mutex. - /// The method will block the calling thread until a lock on the mutex can - /// be obtained. The mutex remains locked until @c unlock() is called. - /// @see lock_guard - inline void lock() - { -#if defined(_TTHREAD_WIN32_) - EnterCriticalSection(&mHandle); -#else - pthread_mutex_lock(&mHandle); -#endif - } - - /// Try to lock the mutex. - /// The method will try to lock the mutex. If it fails, the function will - /// return immediately (non-blocking). - /// @return @c true if the lock was acquired, or @c false if the lock could - /// not be acquired. - inline bool try_lock() - { -#if defined(_TTHREAD_WIN32_) - return TryEnterCriticalSection(&mHandle) ? true : false; -#else - return (pthread_mutex_trylock(&mHandle) == 0) ? true : false; -#endif - } - - /// Unlock the mutex. - /// If any threads are waiting for the lock on this mutex, one of them will - /// be unblocked. - inline void unlock() - { -#if defined(_TTHREAD_WIN32_) - LeaveCriticalSection(&mHandle); -#else - pthread_mutex_unlock(&mHandle); -#endif - } - - _TTHREAD_DISABLE_ASSIGNMENT(recursive_mutex) - - private: -#if defined(_TTHREAD_WIN32_) - CRITICAL_SECTION mHandle; -#else - pthread_mutex_t mHandle; -#endif - - friend class condition_variable; -}; - -/// Lock guard class. -/// The constructor locks the mutex, and the destructor unlocks the mutex, so -/// the mutex will automatically be unlocked when the lock guard goes out of -/// scope. Example usage: -/// @code -/// mutex m; -/// int counter; -/// -/// void increment() -/// { -/// lock_guard guard(m); -/// ++ counter; -/// } -/// @endcode - -template -class lock_guard { - public: - typedef T mutex_type; - - lock_guard() : mMutex(0) {} - - /// The constructor locks the mutex. - explicit lock_guard(mutex_type &aMutex) - { - mMutex = &aMutex; - mMutex->lock(); - } - - /// The destructor unlocks the mutex. - ~lock_guard() - { - if(mMutex) - mMutex->unlock(); - } - - private: - mutex_type * mMutex; -}; - -/// Condition variable class. -/// This is a signalling object for synchronizing the execution flow for -/// several threads. Example usage: -/// @code -/// // Shared data and associated mutex and condition variable objects -/// int count; -/// mutex m; -/// condition_variable cond; -/// -/// // Wait for the counter to reach a certain number -/// void wait_counter(int targetCount) -/// { -/// lock_guard guard(m); -/// while(count < targetCount) -/// cond.wait(m); -/// } -/// -/// // Increment the counter, and notify waiting threads -/// void increment() -/// { -/// lock_guard guard(m); -/// ++ count; -/// cond.notify_all(); -/// } -/// @endcode -class condition_variable { - public: - /// Constructor. -#if defined(_TTHREAD_WIN32_) - condition_variable(); -#else - condition_variable() - { - pthread_cond_init(&mHandle, NULL); - } -#endif - - /// Destructor. -#if defined(_TTHREAD_WIN32_) - ~condition_variable(); -#else - ~condition_variable() - { - pthread_cond_destroy(&mHandle); - } -#endif - - /// Wait for the condition. - /// The function will block the calling thread until the condition variable - /// is woken by @c notify_one(), @c notify_all() or a spurious wake up. - /// @param[in] aMutex A mutex that will be unlocked when the wait operation - /// starts, an locked again as soon as the wait operation is finished. - template - inline void wait(_mutexT &aMutex) - { -#if defined(_TTHREAD_WIN32_) - // Increment number of waiters - EnterCriticalSection(&mWaitersCountLock); - ++ mWaitersCount; - LeaveCriticalSection(&mWaitersCountLock); - - // Release the mutex while waiting for the condition (will decrease - // the number of waiters when done)... - aMutex.unlock(); - _wait(); - aMutex.lock(); -#else - pthread_cond_wait(&mHandle, &aMutex.mHandle); -#endif - } - - /// Notify one thread that is waiting for the condition. - /// If at least one thread is blocked waiting for this condition variable, - /// one will be woken up. - /// @note Only threads that started waiting prior to this call will be - /// woken up. -#if defined(_TTHREAD_WIN32_) - void notify_one(); -#else - inline void notify_one() - { - pthread_cond_signal(&mHandle); - } -#endif - - /// Notify all threads that are waiting for the condition. - /// All threads that are blocked waiting for this condition variable will - /// be woken up. - /// @note Only threads that started waiting prior to this call will be - /// woken up. -#if defined(_TTHREAD_WIN32_) - void notify_all(); -#else - inline void notify_all() - { - pthread_cond_broadcast(&mHandle); - } -#endif - - _TTHREAD_DISABLE_ASSIGNMENT(condition_variable) - - private: -#if defined(_TTHREAD_WIN32_) - void _wait(); - HANDLE mEvents[2]; ///< Signal and broadcast event HANDLEs. - unsigned int mWaitersCount; ///< Count of the number of waiters. - CRITICAL_SECTION mWaitersCountLock; ///< Serialize access to mWaitersCount. -#else - pthread_cond_t mHandle; -#endif -}; - - -/// Thread class. -class thread { - public: -#if defined(_TTHREAD_WIN32_) - typedef HANDLE native_handle_type; -#else - typedef pthread_t native_handle_type; -#endif - - class id; - - /// Default constructor. - /// Construct a @c thread object without an associated thread of execution - /// (i.e. non-joinable). - thread() : mHandle(0), mNotAThread(true) -#if defined(_TTHREAD_WIN32_) - , mWin32ThreadID(0) -#endif - {} - - /// Thread starting constructor. - /// Construct a @c thread object with a new thread of execution. - /// @param[in] aFunction A function pointer to a function of type: - /// void fun(void * arg) - /// @param[in] aArg Argument to the thread function. - /// @note This constructor is not fully compatible with the standard C++ - /// thread class. It is more similar to the pthread_create() (POSIX) and - /// CreateThread() (Windows) functions. - thread(void (*aFunction)(void *), void * aArg); - - /// Destructor. - /// @note If the thread is joinable upon destruction, @c std::terminate() - /// will be called, which terminates the process. It is always wise to do - /// @c join() before deleting a thread object. - ~thread(); - - /// Wait for the thread to finish (join execution flows). - /// After calling @c join(), the thread object is no longer associated with - /// a thread of execution (i.e. it is not joinable, and you may not join - /// with it nor detach from it). - void join(); - - /// Check if the thread is joinable. - /// A thread object is joinable if it has an associated thread of execution. - bool joinable() const; - - /// Detach from the thread. - /// After calling @c detach(), the thread object is no longer assicated with - /// a thread of execution (i.e. it is not joinable). The thread continues - /// execution without the calling thread blocking, and when the thread - /// ends execution, any owned resources are released. - void detach(); - - /// Return the thread ID of a thread object. - id get_id() const; - - /// Get the native handle for this thread. - /// @note Under Windows, this is a @c HANDLE, and under POSIX systems, this - /// is a @c pthread_t. - inline native_handle_type native_handle() - { - return mHandle; - } - - /// Determine the number of threads which can possibly execute concurrently. - /// This function is useful for determining the optimal number of threads to - /// use for a task. - /// @return The number of hardware thread contexts in the system. - /// @note If this value is not defined, the function returns zero (0). - static unsigned hardware_concurrency(); - - _TTHREAD_DISABLE_ASSIGNMENT(thread) - - private: - native_handle_type mHandle; ///< Thread handle. - mutable mutex mDataMutex; ///< Serializer for access to the thread private data. - bool mNotAThread; ///< True if this object is not a thread of execution. -#if defined(_TTHREAD_WIN32_) - unsigned int mWin32ThreadID; ///< Unique thread ID (filled out by _beginthreadex). -#endif - - // This is the internal thread wrapper function. -#if defined(_TTHREAD_WIN32_) - static unsigned WINAPI wrapper_function(void * aArg); -#else - static void * wrapper_function(void * aArg); -#endif -}; - -/// Thread ID. -/// The thread ID is a unique identifier for each thread. -/// @see thread::get_id() -class thread::id { - public: - /// Default constructor. - /// The default constructed ID is that of thread without a thread of - /// execution. - id() : mId(0) {}; - - id(unsigned long int aId) : mId(aId) {}; - - id(const id& aId) : mId(aId.mId) {}; - - inline id & operator=(const id &aId) - { - mId = aId.mId; - return *this; - } - - inline friend bool operator==(const id &aId1, const id &aId2) - { - return (aId1.mId == aId2.mId); - } - - inline friend bool operator!=(const id &aId1, const id &aId2) - { - return (aId1.mId != aId2.mId); - } - - inline friend bool operator<=(const id &aId1, const id &aId2) - { - return (aId1.mId <= aId2.mId); - } - - inline friend bool operator<(const id &aId1, const id &aId2) - { - return (aId1.mId < aId2.mId); - } - - inline friend bool operator>=(const id &aId1, const id &aId2) - { - return (aId1.mId >= aId2.mId); - } - - inline friend bool operator>(const id &aId1, const id &aId2) - { - return (aId1.mId > aId2.mId); - } - - inline friend std::ostream& operator <<(std::ostream &os, const id &obj) - { - os << obj.mId; - return os; - } - - private: - unsigned long int mId; -}; - - -// Related to - minimal to be able to support chrono. -typedef long long __intmax_t; - -/// Minimal implementation of the @c ratio class. This class provides enough -/// functionality to implement some basic @c chrono classes. -template <__intmax_t N, __intmax_t D = 1> class ratio { - public: - static double _as_double() { return double(N) / double(D); } -}; - -/// Minimal implementation of the @c chrono namespace. -/// The @c chrono namespace provides types for specifying time intervals. -namespace chrono { - /// Duration template class. This class provides enough functionality to - /// implement @c this_thread::sleep_for(). - template > class duration { - private: - _Rep rep_; - public: - typedef _Rep rep; - typedef _Period period; - - /// Construct a duration object with the given duration. - template - explicit duration(const _Rep2& r) : rep_(r) {}; - - /// Return the value of the duration object. - rep count() const - { - return rep_; - } - }; - - // Standard duration types. - typedef duration<__intmax_t, ratio<1, 1000000000> > nanoseconds; ///< Duration with the unit nanoseconds. - typedef duration<__intmax_t, ratio<1, 1000000> > microseconds; ///< Duration with the unit microseconds. - typedef duration<__intmax_t, ratio<1, 1000> > milliseconds; ///< Duration with the unit milliseconds. - typedef duration<__intmax_t> seconds; ///< Duration with the unit seconds. - typedef duration<__intmax_t, ratio<60> > minutes; ///< Duration with the unit minutes. - typedef duration<__intmax_t, ratio<3600> > hours; ///< Duration with the unit hours. -} - -/// The namespace @c this_thread provides methods for dealing with the -/// calling thread. -namespace this_thread { - /// Return the thread ID of the calling thread. - thread::id get_id(); - - /// Yield execution to another thread. - /// Offers the operating system the opportunity to schedule another thread - /// that is ready to run on the current processor. - inline void yield() - { -#if defined(_TTHREAD_WIN32_) - Sleep(0); -#else - sched_yield(); -#endif - } - - /// Blocks the calling thread for a period of time. - /// @param[in] aTime Minimum time to put the thread to sleep. - /// Example usage: - /// @code - /// // Sleep for 100 milliseconds - /// this_thread::sleep_for(chrono::milliseconds(100)); - /// @endcode - /// @note Supported duration types are: nanoseconds, microseconds, - /// milliseconds, seconds, minutes and hours. - template void sleep_for(const chrono::duration<_Rep, _Period>& aTime) - { -#if defined(_TTHREAD_WIN32_) - Sleep(int(double(aTime.count()) * (1000.0 * _Period::_as_double()) + 0.5)); -#else - usleep(int(double(aTime.count()) * (1000000.0 * _Period::_as_double()) + 0.5)); -#endif - } -} - -} - -// Define/macro cleanup -#undef _TTHREAD_DISABLE_ASSIGNMENT - -#endif // _TINYTHREAD_H_ diff --git a/depends/xlsxio b/depends/xlsxio new file mode 160000 index 0000000000..e3ed11f6b4 --- /dev/null +++ b/depends/xlsxio @@ -0,0 +1 @@ +Subproject commit e3ed11f6b40bf68b48afc8fc3131ea2b4a22d5b1 diff --git a/depends/zlib/lib/.gitignore b/depends/zlib/lib/.gitignore new file mode 100644 index 0000000000..683bf139fb --- /dev/null +++ b/depends/zlib/lib/.gitignore @@ -0,0 +1 @@ +*.lib diff --git a/depends/zlib/lib/zlib.lib b/depends/zlib/lib/zlib.lib deleted file mode 100644 index 51f579dd77..0000000000 Binary files a/depends/zlib/lib/zlib.lib and /dev/null differ diff --git a/dfhack-config/dwarfmonitor.json b/dfhack-config/dwarfmonitor.json deleted file mode 100644 index 3fd365e746..0000000000 --- a/dfhack-config/dwarfmonitor.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "widgets": [ - { - "type": "weather", - "x": 1, - "y": -1 - }, - { - "type": "date", - "x": -30, - "y": 0, - "format": "Y-M-D" - }, - { - "type": "misery", - "x": -2, - "y": -1, - "anchor": "right" - } - ] -} diff --git a/dfhack.init-example b/dfhack.init-example deleted file mode 100644 index 4d2a1b2f34..0000000000 --- a/dfhack.init-example +++ /dev/null @@ -1,245 +0,0 @@ -############################## -# Generic dwarfmode bindings # -############################## - -# show all current key bindings -keybinding add Ctrl-F1 hotkeys -keybinding add Alt-F1 hotkeys - -# toggle the display of water level as 1-7 tiles -keybinding add Ctrl-W twaterlvl - -# with cursor: - -# designate the whole vein for digging -keybinding add Ctrl-V digv -keybinding add Ctrl-Shift-V "digv x" - -# clean the selected tile of blood etc -keybinding add Ctrl-C spotclean - -# destroy items designated for dump in the selected tile -keybinding add Ctrl-Shift-K autodump-destroy-here - -# set the zone or cage under the cursor as the default -keybinding add Alt-Shift-I@dwarfmode/Zones "zone set" - -# with an item selected: - -# destroy the selected item -keybinding add Ctrl-K autodump-destroy-item - -# scripts: - -# quicksave, only in main dwarfmode screen and menu page -keybinding add Ctrl-Alt-S@dwarfmode/Default quicksave - -# gui/rename script - rename units and buildings -keybinding add Ctrl-Shift-N gui/rename -keybinding add Ctrl-Shift-T "gui/rename unit-profession" - -# a dfhack prompt in df. Sublime text like. -keybinding add Ctrl-Shift-P command-prompt - -# show information collected by dwarfmonitor -keybinding add Alt-M@dwarfmode/Default "dwarfmonitor prefs" -keybinding add Ctrl-F@dwarfmode/Default "dwarfmonitor stats" - -# export a Dwarf's preferences screen in BBCode to post to a forum -keybinding add Ctrl-Shift-F@dwarfmode forum-dwarves - -############################## -# Generic adv mode bindings # -############################## - -keybinding add Ctrl-B@dungeonmode adv-bodyswap -keybinding add Ctrl-Shift-B@dungeonmode "adv-bodyswap force" -keybinding add Shift-O@dungeonmode gui/companion-order - -############################## -# Generic legends bindings # -############################## - -# export all information, or just the detailed maps (doesn't handle site maps) -keybinding add Ctrl-A@legends "exportlegends all" - -############################# -# Context-specific bindings # -############################# - -# Stocks plugin -keybinding add Ctrl-Shift-Z@dwarfmode/Default "stocks show" - -# open an overview window summarising some stocks (dfstatus) -keybinding add Ctrl-Shift-I@dwarfmode/Default "gui/dfstatus" -keybinding add Ctrl-Shift-I@dfhack/lua/dfstatus "gui/dfstatus" - -# q->stockpile - copy & paste stockpiles -keybinding add Alt-P copystock - -# q->stockpile - load and save stockpile settings out of game -keybinding add Alt-L@dwarfmode/QueryBuilding/Some/Stockpile "gui/stockpiles -load" -keybinding add Alt-S@dwarfmode/QueryBuilding/Some/Stockpile "gui/stockpiles -save" - -# q->workshop - duplicate the selected job -keybinding add Ctrl-D job-duplicate - -# materials: q->workshop; b->select items -keybinding add Shift-A "job-material ALUNITE" -keybinding add Shift-M "job-material MICROCLINE" -keybinding add Shift-D "job-material DACITE" -keybinding add Shift-R "job-material RHYOLITE" -keybinding add Shift-I "job-material CINNABAR" -keybinding add Shift-B "job-material COBALTITE" -keybinding add Shift-O "job-material OBSIDIAN" -keybinding add Shift-T "job-material ORTHOCLASE" -keybinding add Shift-G "job-material GLASS_GREEN" - -# sort units and items in the on-screen list -keybinding add Alt-Shift-N "sort-units name" "sort-items description" -keybinding add Alt-Shift-R "sort-units arrival" -keybinding add Alt-Shift-T "sort-units profession" "sort-items type material" -keybinding add Alt-Shift-Q "sort-units squad_position" "sort-items quality" - -# browse linked mechanisms -keybinding add Ctrl-M@dwarfmode/QueryBuilding/Some gui/mechanisms - -# browse rooms of same owner -keybinding add Alt-R@dwarfmode/QueryBuilding/Some gui/room-list - -# interface for the liquids plugin - spawn water/magma/obsidian -keybinding add Alt-L@dwarfmode/LookAround gui/liquids - -# machine power sensitive pressure plate construction -keybinding add Ctrl-Shift-M@dwarfmode/Build/Position/Trap gui/power-meter - -# siege engine control -keybinding add Alt-A@dwarfmode/QueryBuilding/Some/SiegeEngine gui/siege-engine - -# military weapon auto-select -keybinding add Ctrl-W@layer_military/Equip/Customize/View gui/choose-weapons - -# military copy uniform -keybinding add Ctrl-C@layer_military/Uniforms gui/clone-uniform - -# minecart Guide path -keybinding add Alt-P@dwarfmode/Hauling/DefineStop/Cond/Guide gui/guide-path - -# workshop job details -keybinding add Alt-A@dwarfmode/QueryBuilding/Some/Workshop/Job gui/workshop-job - -# autobutcher front-end -keybinding add Shift-B@pet/List/Unit "gui/autobutcher" - -# assign weapon racks to squads so that they can be used -keybinding add P@dwarfmode/QueryBuilding/Some/Weaponrack gui/assign-rack - -############################ -# UI and game logic tweaks # -############################ - -# stabilize the cursor of dwarfmode when switching menus -tweak stable-cursor - -# stop stacked liquid/bar/thread/cloth items from lasting forever -# if used in reactions that use only a fraction of the dimension. -# might be fixed by DF -# tweak fix-dimensions - -# make reactions requiring containers usable in advmode - the issue is -# that the screen asks for those reagents to be selected directly -tweak advmode-contained - -# support Shift-Enter in Trade and Move Goods to Depot screens for faster -# selection; it selects the current item or stack and scrolls down one line -tweak fast-trade - -# stop the right list in military->positions from resetting to top all the time -tweak military-stable-assign -# in same list, color units already assigned to squads in brown & green -tweak military-color-assigned - -# remove inverse dependency of squad training speed on unit list size and use more sparring -# tweak military-training - -# make crafted cloth items wear out with time like in old versions (bug 6003) -tweak craft-age-wear - -# stop adamantine clothing from wearing out (bug 6481) -#tweak adamantine-cloth-wear - -# Add "Select all" and "Deselect all" options to farm plot menus -tweak farm-plot-select - -# Add Shift-Left/Right controls to import agreement screen -tweak import-priority-category - -# Misc. UI tweaks -tweak block-labors # Prevents labors that can't be used from being toggled -tweak civ-view-agreement -tweak fps-min -tweak hide-priority -tweak kitchen-keys -tweak kitchen-prefs-empty -tweak max-wheelbarrow -tweak shift-8-scroll -tweak title-start-rename -tweak tradereq-pet-gender - -########################### -# Globally acting plugins # -########################### - -# Display DFHack version on title screen -enable title-version - -# Dwarf Manipulator (simple in-game Dwarf Therapist replacement) -enable manipulator - -# Search tool in various screens (by falconne) -enable search - -# Improved build material selection interface (by falconne) -enable automaterial - -# Other interface improvement tools -enable \ - confirm \ - dwarfmonitor \ - mousequery \ - autogems \ - automelt \ - autotrade \ - buildingplan \ - resume \ - trackstop \ - zone \ - stocks \ - autochop \ - stockpiles -#end a line with a backslash to make it continue to the next line. The \ is deleted for the final command. -# Multiline commands are ONLY supported for scripts like dfhack.init. You cannot do multiline command manually on the DFHack console. -# You cannot extend a commented line. -# You can comment out the extension of a line. - -# enable mouse controls and sand indicator in embark screen -embark-tools enable sand mouse - -########### -# Scripts # -########### - -# write extra information to the gamelog -modtools/extra-gamelog enable - -# add information to item viewscreens -view-item-info enable - -gui/load-screen enable - -#roses-init must be called on world load if you are using his persist-delay, class system, etc -#base/roses-init -all - -####################################################### -# Apply binary patches at runtime # -####################################################### diff --git a/docs/Authors.rst b/docs/Authors.rst deleted file mode 100644 index ee6f803903..0000000000 --- a/docs/Authors.rst +++ /dev/null @@ -1,115 +0,0 @@ -List of Authors -=============== -The following is a list of people who have contributed to DFHack, in -alphabetical order. - -If you should be here and aren't, please get in touch on IRC or the forums, -or make a pull request! - -======================= ======================= =========================== -Name Github Other -======================= ======================= =========================== -8Z 8Z -acwatkins acwatkins -Alexander Gavrilov angavrilov ag -AndreasPK AndreasPK -Angus Mezick amezick -Antalia tamarakorr -Anuradha Dissanayake falconne -AtomicChicken AtomicChicken -belal jimhester -Ben Lubar BenLubar -Caldfir caldfir -Chris Dombroski cdombroski -Clayton Hughes -David Corbett dscorbett -Deon -DoctorVanGogh DoctorVanGogh -Donald Ruegsegger hashaash -doomchild doomchild -enjia2000 -Eric Wald eswald -Erik Youngren Artanis -Espen Wiborg -expwnent expwnent -Feng -gchristopher gchristopher -Harlan Playford playfordh -Hayati Ayguen hayguen -IndigoFenix -James Logsdon jlogsdon -Japa JapaMala -Jared Adams -Jim Lisi stonetoad -jj jjyg jj`` -John Beisley huin -John Shade gsvslto -Jonas Ask -kane-t kane-t -Kelly Kinkade ab9rf -Kris Parker kaypy -Kurik Amudnil -Lethosor lethosor -Mason11987 Mason11987 -Matthew Cline -Max maxthyme Max^TM -melkor217 melkor217 -Meneth32 -Meph -Michon van Dooren MaienM -miffedmap miffedmap -Mike Stewart thewonderidiot -Mikko Juola Noeda Adeon -MithrilTuxedo MithrilTuxedo -mizipzor mizipzor -moversti moversti -Neil Little nmlittle -Nick Rart nickrart comestible -Omniclasm -PeridexisErrant PeridexisErrant -Petr Mrázek peterix -potato -Priit Laes plaes -Putnam Putnam3145 -Quietust quietust _Q -Raidau Raidau -Ramblurr Ramblurr -rampaging-poet -Raoul van Putten -Raoul XQ raoulxq -reverb -Rinin Rinin -Robert Heinrich rh73 -Robert Janetzko robertjanetzko -rofl0r rofl0r -root -Roses Pheosics -Ross M RossM -rout -rubybrowncoat rubybrowncoat -Rumrusher rumrusher -RusAnon RusAnon -sami -scamtank scamtank -Sebastian Wolfertz Enkrod -Seth Woodworth sethwoodworth -simon -Simon Jackson sizeak -stolencatkarma -sv-esk sv-esk -Tacomagic -Tim Walberg twalberg -Timothy Collett danaris -Tom Jobbins TheBloke -Tom Prince -Travis Hoppe thoppe orthographic-pedant -txtsd txtsd -U-glouglou\\simon -Valentin Ochs Cat-Ion -Vjek -Warmist warmist -Wes Malone wesQ3 -Will Rogers wjrogers -Zhentar Zhentar -zilpin zilpin -======================= ======================= =========================== diff --git a/docs/Compile.rst b/docs/Compile.rst deleted file mode 100644 index 650abbfcac..0000000000 --- a/docs/Compile.rst +++ /dev/null @@ -1,637 +0,0 @@ -################ -Compiling DFHack -################ - -You don't need to compile DFHack unless you're developing plugins or working on the core. - -For users, modders, and authors of scripts it's better to download -and `install the latest release instead `. - -.. contents:: - :depth: 2 - -.. _compile-how-to-get-the-code: - -How to get the code -=================== -DFHack doesn't have any kind of system of code snapshots in place, so you will have to -get code from the GitHub repository using Git. How to get Git is described under -the instructions for each platform. - -To get the latest release code (master branch):: - - git clone --recursive https://github.com/DFHack/dfhack - cd dfhack - -If your version of Git does not support the ``--recursive`` flag, you will need to omit it and run -``git submodule update --init`` after entering the dfhack directory. - -To get the latest development code (develop branch), clone as above and then:: - - git checkout develop - git submodule update - -**Important note regarding submodule update and changing branches**: - -You must run ``git submodule update`` every time you change Git branch, -for example when switching between master and develop branches and back. -If a submodule only exists on the newer branch, you also need to run -``git submodule update --init``. Failure to do this may result in strange -build errors or "not a known DF version" errors. - -**Important note regarding very old git versions** - -If you are using git 1.8.0 or older, and cloned DFHack before commit 85a920d -(around DFHack v0.43.03-alpha1), you may run into fatal git errors when updating -submodules after switching branches. This is due to those versions of git being -unable to handle our change from "scripts/3rdparty/name" submodules to a single -"scripts" submodule. This may be fixable by renaming .git/modules/scripts to -something else and re-running ``git submodule update --init`` on the branch with -the single scripts submodule (and running it again when switching back to the -one with multiple submodules, if necessary), but it is usually much simpler to -upgrade your git version. - -Contributing to DFHack -====================== -If you want to get involved with the development, create an account on -GitHub, make a clone there and then use that as your remote repository instead. - -We'd love that; join us on IRC_ (#dfhack channel on freenode) for discussion, -and whenever you need help. - -.. _IRC: https://webchat.freenode.net/?channels=dfhack - -(Note: for submodule issues, please see the above instructions first!) - -For lots more details on contributing to DFHack, including pull requests, code format, -and more, please see `contributing-code`. - - -Build types -=========== -``cmake`` allows you to pick a build type by changing the ``CMAKE_BUILD_TYPE`` variable:: - - cmake .. -DCMAKE_BUILD_TYPE:string=BUILD_TYPE - -Without specifying a build type or 'None', cmake uses the -``CMAKE_CXX_FLAGS`` variable for building. - -Valid and useful build types include 'Release', 'Debug' and -'RelWithDebInfo'. -'Debug' is not available on Windows, use 'RelWithDebInfo' instead. - - -Linux -===== -On Linux, DFHack acts as a library that shadows parts of the SDL API using LD_PRELOAD. - -Dependencies ------------- -DFHack is meant to be installed into an existing DF folder, so get one ready. - -We assume that any Linux platform will have ``git`` available (though it may -require installing from your package manager.) - -To build DFHack you need GCC version 4.5 or later, capable of compiling for 32-bit -(i386) targets. GCC 4.5 is easiest to work with due to avoiding libstdc++ issues -(see below), but any version from 4.5 onwards (including 5.x) will work. - -On 64-bit distributions, you'll need the multilib development tools and libraries: - -* ``gcc-multilib`` and ``g++-multilib`` -* If you have installed a non-default version of GCC - for example, GCC 4.5 on a - distribution that defaults to 5.x - you may need to add the version number to - the multilib packages. - - * For example, ``gcc-4.5-multilib`` and ``g++-4.5-multilib`` if installing for GCC 4.5 - on a system that uses a later GCC version. - * This is definitely required on Ubuntu/Debian, check if using a different distribution. - -Note that installing a 32-bit GCC on 64-bit systems (e.g. ``gcc:i386`` on Debian) will -typically *not* work, as it depends on several other 32-bit libraries that -conflict with system libraries. Alternatively, you might be able to use ``lxc`` -to -:forums:`create a virtual 32-bit environment <139553.msg5435310#msg5435310>`. - -Before you can build anything, you'll also need ``cmake``. It is advisable to also get -``ccmake`` on distributions that split the cmake package into multiple parts. - -You also need perl and the XML::LibXML and XML::LibXSLT perl packages (for the code generation parts). -You should be able to find them in your distro repositories. - -To build `stonesense`, you'll also need OpenGL headers. - -Here are some package install commands for various platforms: - -* On Arch linux: - - * For the required Perl modules: ``perl-xml-libxml`` and ``perl-xml-libxslt`` (or through ``cpan``) - -* On 64-bit Ubuntu:: - - apt-get install gcc cmake git gcc-multilib g++-multilib zlib1g-dev:i386 libxml-libxml-perl libxml-libxslt-perl - -* On 32-bit Ubuntu:: - - apt-get install gcc cmake git gcc-multilib g++-multilib zlib1g-dev libxml-libxml-perl libxml-libxslt-perl - -* Debian and derived distros should have similar requirements to Ubuntu. - - -Build ------ -Building is fairly straightforward. Enter the ``build`` folder (or create an -empty folder in the DFHack directory to use instead) and start the build like this:: - - cd build - cmake .. -DCMAKE_BUILD_TYPE:string=Release -DCMAKE_INSTALL_PREFIX= - make install # or make -jX install on multi-core systems to compile with X parallel processes - - should be a path to a copy of Dwarf Fortress, of the appropriate -version for the DFHack you are building. This will build the library along -with the normal set of plugins and install them into your DF folder. - -Alternatively, you can use ccmake instead of cmake:: - - cd build - ccmake .. - make install - -This will show a curses-based interface that lets you set all of the -extra options. You can also use a cmake-friendly IDE like KDevelop 4 -or the cmake-gui program. - -Incompatible libstdc++ -~~~~~~~~~~~~~~~~~~~~~~ -When compiling dfhack yourself, it builds against your system libstdc++. -When Dwarf Fortress runs, it uses a libstdc++ shipped with the binary, which -comes from GCC 4.5 and is incompatible with code compiled with newer GCC versions. -This manifests itself with an error message such as:: - - ./libs/Dwarf_Fortress: /pathToDF/libs/libstdc++.so.6: version - `GLIBCXX_3.4.15' not found (required by ./hack/libdfhack.so) - -To fix this you can compile with GCC 4.5 or remove the libstdc++ shipped with -DF, which causes DF to use your system libstdc++ instead:: - - cd /path/to/DF/ - rm libs/libstdc++.so.6 - -Note that distributing binaries compiled with newer GCC versions requires end- -users to delete libstdc++ themselves and have a libstdc++ on their system from -the same GCC version or newer. For this reason, distributing anything compiled -with GCC versions newer than 4.5 is discouraged. In the future we may start -bundling a later libstdc++ as part of the DFHack package, so as to enable -compilation-for-distribution with a GCC newer than 4.5. - -Mac OS X -======== -DFHack functions similarly on OS X and Linux, and the majority of the -information above regarding the build process (cmake and make) applies here -as well. - -If you have issues building on OS X 10.10 (Yosemite) or above, try definining the -following environment variable:: - - export MACOSX_DEPLOYMENT_TARGET=10.9 - -Note for El Capitan (OSX 10.11) and XCode 7.x users ---------------------------------------------------- - -* You will probably find when following the instructions below that GCC 4.5 will - fail to install on OSX 10.11, or any older OSX that is using XCode 7. -* There are two workarounds: - - * Install GCC 5.x instead (``brew install gcc5``), and then after compile - replace ``hack/libstdc++.6.dylib`` with a symlink to GCC 5's i386 - version of this file:: - - cd /hack && mv libstdc++.6.dylib libstdc++.6.dylib.orig && - ln -s /usr/local/Cellar/gcc5/5.2.0/lib/gcc/5/i386/libstdc++.6.dylib . - - * Install XCode 6, which is available as a free download from the Apple - Developer Center. - - * Either install this as your only XCode, or install it additionally - to XCode 7 and then switch between them using ``xcode-select`` - * Ensure XCode 6 is active before attempting to install GCC 4.5 and - whenever you are compiling DFHack with GCC 4.5. - -Dependencies and system set-up ------------------------------- - -#. Download and unpack a copy of the latest DF -#. Install Xcode from Mac App Store - -#. Install the XCode Command Line Tools by running the following command:: - - xcode-select --install - -#. Install dependencies - - Using `Homebrew `_ (recommended):: - - brew tap homebrew/versions - brew install git - brew install cmake - brew install gcc45 - - Using `MacPorts `_:: - - sudo port install gcc45 +universal cmake +universal git-core +universal - - Macports will take some time - maybe hours. At some point it may ask - you to install a Java environment; let it do so. - - It is recommended to use Homebrew instead of MacPorts, as it is generally - cleaner, quicker, and smarter. For example, installing - MacPort's GCC 4.5 will install more than twice as many dependencies - as Homebrew's will, and all in both 32bit and 64bit variants. - Homebrew also doesn't require constant use of sudo. - -#. Install Perl dependencies - - * Using system Perl - - * ``sudo cpan`` - - If this is the first time you've run cpan, you will need to go through the setup - process. Just stick with the defaults for everything and you'll be fine. - - If you are running OS X 10.6 (Snow Leopard) or earlier, good luck! - You'll need to open a separate Terminal window and run:: - - sudo ln -s /usr/include/libxml2/libxml /usr/include/libxml - - * ``install XML::LibXML`` - * ``install XML::LibXSLT`` - - * In a separate, local Perl install - - Rather than using system Perl, you might also want to consider - the Perl manager, `Perlbrew `_. - - This manages Perl 5 locally under ``~/perl5/``, providing an easy - way to install Perl and run CPAN against it without ``sudo``. - It can maintain multiple Perl installs and being local has the - benefit of easy migration and insulation from OS issues and upgrades. - - See http://perlbrew.pl/ for more details. - -Building --------- - -* Get the DFHack source as per section `compile-how-to-get-the-code`, above. -* Set environment variables - - Homebrew (if installed elsewhere, replace /usr/local with ``$(brew --prefix)``):: - - export CC=/usr/local/bin/gcc-4.5 - export CXX=/usr/local/bin/g++-4.5 - - Macports:: - - export CC=/opt/local/bin/gcc-mp-4.5 - export CXX=/opt/local/bin/g++-mp-4.5 - - Change the version numbers appropriately if you installed a different version of GCC. - -* Build dfhack:: - - mkdir build-osx - cd build-osx - cmake .. -DCMAKE_BUILD_TYPE:string=Release -DCMAKE_INSTALL_PREFIX= - make install # or make -j X install on multi-core systems to compile with X parallel processes - - should be a path to a copy of Dwarf Fortress, of the appropriate - version for the DFHack you are building. - -.. _compile-windows: - -Windows -======= -On Windows, DFHack replaces the SDL library distributed with DF. - -Dependencies ------------- -You will need the following: - -* Microsoft Visual Studio 2010 SP1, with the C++ language -* Git -* CMake -* Perl with XML::LibXML and XML::LibXSLT - - * It is recommended to install StrawberryPerl, which includes both. - -Microsoft Visual Studio 2010 SP1 -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -DFHack has to be compiled with the Microsoft Visual C++ 2010 SP1 toolchain; later -versions won't work against Dwarf Fortress due to ABI and STL incompatibilities. - -At present, the only way to obtain the MSVC C++ 2010 toolchain is to install a -full copy of Microsoft Visual Studio 2010 SP1. The free Express version is sufficient. - -You can grab it from `Microsoft's site `_. - -You should also install the Visual Studio 2010 SP1 update. - -You can confirm whether you have SP1 by opening the Visual Studio 2010 IDE -and selecting About from the Help menu. If you have SP1 it will have *SP1Rel* -at the end of the version number, for example: *Version 10.0.40219.1 SP1Rel* - -Use of pre-SP1 releases has been reported to cause issues and is therefore not -supported by DFHack. Please ensure you are using SP1 before raising any Issues. - -If your Windows Update is configured to receive updates for all Microsoft -Products, not just Windows, you will receive the SP1 update automatically -through Windows Update (you will probably need to trigger a manual check.) - -If not, you can download it directly `from this Microsoft Download link `_. - -Additional dependencies: installing with the Chocolatey Package Manager -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -The remainder of dependencies - Git, CMake and StrawberryPerl - can be most -easily installed using the Chocolatey Package Manger. Chocolatey is a -\*nix-style package manager for Windows. It's fast, small (8-20MB on disk) -and very capable. Think "``apt-get`` for Windows." - -Chocolatey is a preferred way of installing the required dependencies -as it's quicker, less effort and will install known-good utilities -guaranteed to have the correct setup (especially PATH). - -To install Chocolatey and the required dependencies: - -* Go to https://chocolatey.org in a web browser -* At the top of the page it will give you the install command to copy - - * Copy the first one, which starts ``@powershell ...`` - * It won't be repeated here in case it changes in future Chocolatey releases. - -* Open an elevated (Admin) ``cmd.exe`` window - - * On Windows 8 and later this can be easily achieved by: - - * right-clicking on the Start Menu, or pressing Win+X. - * choosing "Command Prompt (Admin)" - - * On earlier Windows: find ``cmd.exe`` in Start Menu, right click - and choose Open As Administrator. - -* Paste in the Chocolatey install command and hit enter -* Close this ``cmd.exe`` window and open another Admin ``cmd.exe`` in the same way -* Run the following command:: - - choco install git cmake.portable strawberryperl -y - -* Close the Admin ``cmd.exe`` window; you're done! - -You can now use all of these utilities from any normal ``cmd.exe`` window. -You only need Admin/elevated ``cmd.exe`` for running ``choco install`` commands; -for all other purposes, including compiling DFHack, you should use -a normal ``cmd.exe`` (or, better, an improved terminal like `Cmder `_; -details below, under Build.) - -**NOTE**: you can run the above ``choco install`` command even if you already have -Git, CMake or StrawberryPerl installed. Chocolatey will inform you if any software -is already installed and won't re-install it. In that case, please check the PATHs -are correct for that utility as listed in the manual instructions below. Or, better, -manually uninstall the version you have already and re-install via Chocolatey, -which will ensure the PATH are set up right and will allow Chocolatey to manage -that program for you in future. - -Additional dependencies: installing manually -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -If you prefer to install manually rather than using Chocolatey, details and -requirements are as below. If you do install manually, please ensure you -have all PATHs set up correctly. - -Git -^^^ -Some examples: - -* `Git for Windows `_ (command-line and GUI) -* `tortoisegit `_ (GUI and File Explorer integration) - -CMake -^^^^^ -You can get the win32 installer version from -`the official site `_. -It has the usual installer wizard. Make sure you let it add its binary folder -to your binary search PATH so the tool can be later run from anywhere. - -Perl / Strawberry Perl -^^^^^^^^^^^^^^^^^^^^^^ -For the code generation parts you'll need Perl 5 with XML::LibXML and XML::LibXSLT. -`Strawberry Perl `_ is recommended as it includes -all of the required packages in a single, easy install. - -After install, ensure Perl is in your user's PATH. This can be edited from -``Control Panel -> System -> Advanced System Settings -> Environment Variables``. - -The following three directories must be in PATH, in this order: - -* ``\c\bin`` -* ``\perl\site\bin`` -* ``\perl\bin`` - -Be sure to close and re-open any existing ``cmd.exe`` windows after updating -your PATH. - -If you already have a different version of Perl (for example the one from Cygwin), -you can run into some trouble. Either remove the other Perl install from PATH, or -install XML::LibXML and XML::LibXSLT for it using CPAN. - -Build ------ -There are several different batch files in the ``build`` folder along -with a script that's used for picking the DF path. - -First, run ``set_df_path.vbs`` and point the dialog that pops up at -a suitable DF installation which is of the appropriate version for the DFHack -you are compiling. The result is the creation of the file ``DF_PATH.txt`` in -the build directory. It contains the full path to the destination directory. -You could therefore also create this file manually - or copy in a pre-prepared -version - if you prefer. - -Next, run one of the scripts with ``generate`` prefix. These create the MSVC -solution file(s): - -* ``all`` will create a solution with everything enabled (and the kitchen sink). -* ``gui`` will pop up the CMake GUI and let you choose what to build. - This is probably what you want most of the time. Set the options you are interested - in, then hit configure, then generate. More options can appear after the configure step. -* ``minimal`` will create a minimal solution with just the bare necessities - - the main library and standard plugins. - -Then you can either open the solution with MSVC or use one of the msbuild scripts: - -Building/installing from the command line: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -In the build directory you will find several ``.bat`` files: - -* Scripts with ``build`` prefix will only build DFHack. -* Scripts with ``install`` prefix will build DFHack and install it to the previously selected DF path. -* Scripts with ``package`` prefix will build and create a .zip package of DFHack. - -Compiling from the command line is generally the quickest and easiest option. -However be aware that due to the limitations of ``cmd.exe`` - especially in -versions of Windows prior to Windows 10 - it can be very hard to see what happens -during a build. If you get a failure, you may miss important errors or warnings -due to the tiny window size and extremely limited scrollback. For that reason you -may prefer to compile in the IDE which will always show all build output. - -Alternatively (or additionally), consider installing an improved Windows terminal -such as `Cmder `_. Easily installed through Chocolatey with: -``choco install cmder -y``. - -**Note for Cygwin/msysgit users**: It is also possible to compile DFHack from a -Bash command line. This has three potential benefits: - -* When you've installed Git and are using its Bash, but haven't added Git to your path: - - * You can load Git's Bash and as long as it can access Perl and CMake, you can - use it for compile without adding Git to your system path. - -* When you've installed Cygwin and its SSH server: - - * You can now SSH in to your Windows install and compile from a remote terminal; - very useful if your Windows installation is a local VM on a \*nix host OS. - -* In general: you can use Bash as your compilation terminal, meaning you have a decent - sized window, scrollback, etc. - - * Whether you're accessing it locally as with Git's Bash, or remotely through - Cygwin's SSH server, this is far superior to using ``cmd.exe``. - -You don't need to do anything special to compile from Bash. As long as your PATHs -are set up correctly, you can run the same generate- and build/install/package- bat -files as detailed above. - -Building/installing from the Visual Studio IDE: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -After running the CMake generate script you will have a new folder called VC2010. -Open the file ``dfhack.sln`` inside that folder. If you have multiple versions of -Visual Studio installed, make sure you open with Visual Studio 2010. - -The first thing you must then do is change the build type. It defaults to Debug, -but this cannot be used on Windows. Debug is not binary-compatible with DF. -If you try to use a debug build with DF, you'll only get crashes and for this -reason the Windows "debug" scripts actually do RelWithDebInfo builds. -After loading the Solution, change the Build Type to either ``Release`` -or ``RelWithDebInfo``. - -Then build the ``INSTALL`` target listed under ``CMakePredefinedTargets``. - - -Building the documentation -========================== - -DFHack documentation, like the file you are reading now, is created as .rst files, -which are in `reStructuredText (reST) `_ format. -This is a documenation format that has come from the Python community. It is very -similar in concept - and in syntax - to Markdown, as found on GitHub and many other -places. However it is more advanced than Markdown, with more features available when -compiled to HTML, such as automatic tables of contents, cross-linking, special -external links (forum, wiki, etc) and more. The documentation is compiled by a -Python tool, `Sphinx `_. - -The DFHack build process will compile the documentation but this has been disabled -by default. You only need to build the docs if you're changing them, or perhaps -if you want a local HTML copy; otherwise, read them easily online at -`ReadTheDoc's DFHack hosted documentation `_. - -(Note that even if you do want a local copy, it is certainly not necesesary to -compile the documentation in order to read it. Like Markdown, reST documents are -designed to be just as readable in a plain-text editor as they are in HTML format. -The main thing you lose in plain text format is hyperlinking.) - - -Enabling documentation building -------------------------------- -First, make sure you have followed all the necessary steps for your platform as -outlined in the rest of this document. - -To compile documentation with DFHack, add the following flag to your ``cmake`` command:: - - -DBUILD_DOCS:bool=ON - -For example:: - - cmake .. -DCMAKE_BUILD_TYPE:string=Release -DBUILD_DOCS:bool=ON -DCMAKE_INSTALL_PREFIX= - -Alternatively you can use the CMake GUI which allows options to be changed easily. - -On Windows you should either use ``generate-msvc-gui.bat`` and set the option -through the GUI, or else if you want to use an alternate file, such as -``generate-msvc-all.bat``, you will need to edit it to add the flag. -Or you could just run ``cmake`` on the command line like in other platforms. - -Required dependencies ---------------------- -In order to build the documentation, you must have Python with Sphinx -version 1.3.1 or later. Both Python 2.x and 3.x are supported. - -When installing Sphinx from OS package managers, be aware that there is -another program called Sphinx, completely unrelated to documentation management. -Be sure you are installing the right Sphinx; it may be called ``python-sphinx``, -for example. To avoid doubt, ``pip`` can be used instead as detailed below. - - -Linux ------ -Most Linux distributions will include Python as standard. - -Check your package manager to see if Sphinx 1.3.1 or later is available, -but at the time of writing Ubuntu for example only has 1.2.x. - -You can instead install Sphinx with the pip package manager. This may need -to be installed from your OS package manager; this is the case on Ubuntu. -On Ubuntu/Debian, use the following to first install pip:: - - sudo apt-get install python-pip - -Once pip is available, you can then install the Python Sphinx module with:: - - pip install sphinx - -If you run this as a normal user it will install a local copy for your user only. -Run it with sudo if you want a system-wide install. Either is fine for DFHack, -however if installing locally do check that ``sphinx-build`` is in your path. -It may be installed in a directory such as ``~/.local/bin/``, so after pip -install, find ``sphinx-build`` and ensure its directory is in your local ``$PATH``. - - -Mac OS X --------- -OS X has Python 2.7 installed by default, but it does not have the pip package manager. - -You can install Homebrew's Python 3, which includes pip, and then install the -latest Sphinx using pip:: - - brew install python3 - pip3 install sphinx - -Alternatively, you can simply install Sphinx 1.3.x directly from Homebrew:: - - brew install sphinx-doc - -This will install Sphinx for OS X's system Python 2.7, without needing pip. - -Either method works; if you plan to use Python for other purposes, it might best -to install Homebrew's Python 3 so that you have the latest Python as well as pip. -If not, just installing sphinx-doc for OS X's system Python 2.7 is fine. - - -Windows -------- -Use the Chocolatey package manager to install Python and pip, -then use pip to install Sphinx. - -Run the following commands from an elevated (Admin) ``cmd.exe``, after installing -Chocolatey as outlined in the `Windows section `:: - - choco install python pip -y - -Then close that Admin ``cmd.exe``, re-open another Admin ``cmd.exe``, and run:: - - pip install sphinx diff --git a/docs/Core.rst b/docs/Core.rst index a65d16e12c..b386e5ea04 100644 --- a/docs/Core.rst +++ b/docs/Core.rst @@ -4,359 +4,468 @@ DFHack Core ########### -DFHack commands can be implemented in three ways, all of which -are used in the same way: +.. contents:: Contents + :local: + :depth: 2 + + +Command implementation +====================== +DFHack commands can be implemented in any of three ways: :builtin: commands are implemented by the core of DFHack. They manage - other DFhack tools, interpret commands, and control basic + other DFHack tools, interpret commands, and control basic aspects of DF (force pause or quit). :plugins: are stored in ``hack/plugins/`` and must be compiled with the same version of DFHack. They are less flexible than scripts, - but used for complex or ongoing tasks becasue they run faster. + but used for complex or ongoing tasks because they run faster. -:scripts: are Ruby or Lua scripts stored in ``hack/scripts/``. - Because they don't need to be compiled, scripts are - more flexible about versions, and easier to distribute. - Most third-party DFHack addons are scripts. +:scripts: are Lua scripts stored in ``hack/scripts/`` or other + directories in the `script-paths`. Because they don't need to + be compiled, scripts are more flexible about versions, and + they are easier to distribute. Most third-party DFHack addons + are scripts. +All tools distributed with DFHack are documented `here `. -.. contents:: +Using DFHack commands +===================== +DFHack commands can be executed in a number of ways: +#. Typing the command into the DFHack console (see below) +#. From the OS terminal (see below) +#. Pressing a key combination set up with `keybinding` +#. From one of several `init-files`, automatically +#. Using `script` to run a batch of commands from a file +#. From an in-game command launcher interface like `gui/launcher`, the + `hotkeys` overlay widget, or `gui/quickcmd`. -Built-in Commands -================= -The following commands are provided by the 'core' components -of DFhack, rather than plugins or scripts. +The DFHack console +------------------ +The command line has some nice line editing capabilities, including history +that's preserved between different runs of DF - use :kbd:`↑` and :kbd:`↓` +to go through the history. +To include whitespace in the argument/s to some command, quote it in +double quotes. To include a double quote character, use ``\"``. -.. _cls: +If the first non-whitespace character is ``:``, the command is parsed in +an alternative mode. The non-whitespace characters following the ``:`` are +the command name, and the remaining part of the line is used verbatim as +the first argument. This is very useful for the `lua` command. +As an example, the following two command lines are exactly equivalent:: -cls ---- -Clear the terminal. Does not delete command history. + :foo a b "c d" e f + foo "a b \"c d\" e f" +Using an OS terminal +-------------------- +DFHack commands can be run from an OS terminal at startup, using '+ args', +or at any other time using the ``dfhack-run`` executable. -.. _die: +If DF/DFHack is started with arguments beginning with ``+``, the remaining +text is treated as a command in the DFHack console. It is possible to use +multiple such commands, which are split on ``+``. For example: -die ---- -Instantly kills DF without saving. +.. code-block:: shell + ./dfhack +load-save region1 + "Dwarf Fortress.exe" +devel/print-args Hello! +enable workflow -.. _disable: +The first example (\*nix), `load-save`, skips the main menu and loads +``region1`` immediately. The second (Windows) example prints +:guilabel:`Hello!` in the DFHack console, and `enables ` `workflow`. +Note that the ``:foo`` syntax for whitespace in arguments is not compatible \ +with '+ args'. -.. _enable: -enable ------- -Many plugins can be in a distinct enabled or disabled state. Some of -them activate and deactivate automatically depending on the contents -of the world raws. Others store their state in world data. However a -number of them have to be enabled globally, and the init file is the -right place to do it. +.. _dfhack-run: -Most such plugins or scripts support the built-in ``enable`` and ``disable`` -commands. Calling them at any time without arguments prints a list -of enabled and disabled plugins, and shows whether that can be changed -through the same commands. +dfhack-run +.......... -To enable or disable plugins that support this, use their names as -arguments for the command:: +If DF and DFHack are already running, calling ``dfhack-run my command`` +in an external terminal is equivalent to calling ``my command`` in the +DFHack console. Direct use of the DFHack console is generally easier, +but ``dfhack-run`` can be useful in a variety of circumstances: - enable manipulator search +- if the console is unavailable + - with the init setting ``PRINT_MODE:TEXT`` + - while running an interactive command (e.g. `liquids` or `tiletypes`) -.. _fpause: +- from external programs or scripts +- if DF or DFHack are not responding -fpause ------- -Forces DF to pause. This is useful when your FPS drops below 1 and you lose -control of the game. +Examples: +.. code-block:: shell -.. _help: + ./dfhack-run cursecheck + dfhack-run kill-lua -help ----- -Most commands support using the ``help `` built-in command -to retrieve further help without having to look at this document. -``? `` and ``man `` are aliases. +The first (\*nix) example `checks for vampires `; the +second (Windows) example uses `kill-lua` to stop a Lua script. -Some commands (including many scripts) instead take ``help`` or ``?`` -as an option on their command line - ie `` help``. +.. note:: + ``dfhack-run`` attempts to connect to a server on TCP port 5000. If DFHack + was unable to start this server, ``dfhack-run`` will not be able to connect. + This could happen if you have other software listening on port 5000, or if + you have multiple copies of DF running simultaneously. To assign a different + port, see `remote-server-config`. -.. _hide: +.. _dfhack-config: -hide ----- -Hides the DFHack terminal window. Only available on Windows. +Configuration files +=================== +Most DFHack settings can be changed by modifying files in the ``dfhack-config`` +folder (which is in the DF folder). The default versions of these files, if they +exist, are in ``dfhack-config/default`` and are installed when DFHack starts if +necessary. -.. _keybinding: +.. _init-files: -keybinding +Init files ---------- -To set keybindings, use the built-in ``keybinding`` command. Like any other -command it can be used at any time from the console, but bindings are not -remembered between runs of the game unless re-created in `dfhack.init`. - -Currently, any combinations of Ctrl/Alt/Shift with A-Z, 0-9, or F1-F12 are supported. - -Possible ways to call the command: - -``keybinding list `` - List bindings active for the key combination. -``keybinding clear ...`` - Remove bindings for the specified keys. -``keybinding add "cmdline" "cmdline"...`` - Add bindings for the specified key. -``keybinding set "cmdline" "cmdline"...`` - Clear, and then add bindings for the specified key. - -The ```` parameter above has the following *case-sensitive* syntax:: - - [Ctrl-][Alt-][Shift-]KEY[@context[|context...]] - -where the *KEY* part can be any recognized key and [] denote optional parts. - -When multiple commands are bound to the same key combination, DFHack selects -the first applicable one. Later ``add`` commands, and earlier entries within one -``add`` command have priority. Commands that are not specifically intended for use -as a hotkey are always considered applicable. - -The ``context`` part in the key specifier above can be used to explicitly restrict -the UI state where the binding would be applicable. If called without parameters, -the ``keybinding`` command among other things prints the current context string. - -Only bindings with a ``context`` tag that either matches the current context fully, -or is a prefix ending at a ``/`` boundary would be considered for execution, i.e. -when in context ``foo/bar/baz``, keybindings restricted to any of ``@foo/bar/baz``, -``@foo/bar``, ``@foo`` or none will be active. -Multiple contexts can be specified by separating them with a -pipe (``|``) - for example, ``@foo|bar|baz/foo`` would match -anything under ``@foo``, ``@bar``, or ``@baz/foo``. - -Interactive commands like `liquids` cannot be used as hotkeys. - - -.. _kill-lua: - -kill-lua --------- -Stops any currently-running Lua scripts. By default, scripts can -only be interrupted every 256 instructions. Use ``kill-lua force`` -to interrupt the next instruction. +.. contents:: + :local: +DFHack allows users to automatically run commonly-used DFHack commands +when DF is first loaded, when a world is loaded, when a map is loaded, when a +map is unloaded, and when a world is unloaded. -.. _load: -.. _unload: -.. _reload: +Init scripts function the same way they would if the user manually typed +in their contents, but are much more convenient. In order to facilitate +savegave portability, mod merging, and general organization of init files, +DFHack supports multiple init files both in the main DF directory and +save-specific init files in the save folders. -load ----- -``load``, ``unload``, and ``reload`` control whether a plugin is loaded -into memory - note that plugins are loaded but disabled unless you do -something. Usage:: +DFHack looks for init files in two places each time they could be run: - load|unload|reload PLUGIN|(-a|--all) +#. The :file:`dfhack-config/init` subdirectory in the main DF directory and +#. :file:`save/{world}/init`, where ``{world}`` is the current save -Allows dealing with plugins individually by name, or all at once. +For each of those directories, all matching init files will be executed in +alphabetical order. +Before running matched init scripts in any of those locations, the +:file:`dfhack-config/init/default.*` file that matches the event will be run to +load DFHack defaults. Only the :file:`dfhack-config/init` directory is checked +for this file, not any :file:`save` directories. If you want DFHack to load +without running any of its default configuration commands, edit the +:file:`dfhack-config/init/default.*` files and comment out the commands you see +there. -.. _ls: +When reading commands from the init files or with the `script` command, if the +final character on a line is a backslash then the next uncommented line is +considered a continuation of that line, with the backslash deleted. Commented +lines are skipped, so it is possible to comment out parts of a command with the +``#`` character. -ls --- -``ls`` does not list files like the Unix command, but rather -available commands - first built in commands, then plugins, -and scripts at the end. Usage: +.. _dfhack.init: -:ls -a: Also list scripts in subdirectories of ``hack/scripts/``, - which are generally not intended for direct use. -:ls : List subcommands for the given plugin. +dfhack\*.init +............. +On startup, DFHack looks for files of the form ``dfhack*.init`` (where ``*`` is +a placeholder for any string, including the empty string). +These files are best used for keybindings and enabling persistent tools +which do not require a world to be loaded. -.. _plug: -plug ----- -Lists available plugins, including their state and detailed description. +.. _onLoad.init: -``plug`` - Lists available plugins (*not* commands implemented by plugins) -``plug [PLUGIN] [PLUGIN] ...`` - List state and detailed description of the given plugins, - including commands implemented by the plugin. +onLoad\*.init +............. +When a world is loaded, DFHack looks for files of the form ``onLoad*.init``, +where ``*`` can be any string, including the empty string. +A world being loaded can mean a fortress, an adventurer, or legends mode. -.. _sc-script: +These files are best used for non-persistent commands, such as setting +a `bugfix-tag-index` script to run on `repeat`. -sc-script ---------- -Allows additional scripts to be run when certain events occur -(similar to onLoad*.init scripts) +.. _onMapLoad.init: -.. _script: +onMapLoad\*.init +................ +When a map is loaded, either in adventure or fort mode, DFHack looks for files +of the form ``onMapLoad*.init``, where ``*`` can be any string, including the +empty string. -script ------- -Reads a text file, and runs each line as a DFHack command -as if it had been typed in by the user - treating the -input like `an init file `. +These files are best used for commands that are only relevant once there is a +game map loaded. -Some other tools, such as `autobutcher` and `workflow`, export -their settings as the commands to create them - which are later -loaded with ``script`` +.. _onMapUnload.init: +.. _onUnload.init: -.. _show: +onMapUnload\*.init and onUnload\*.init +...................................... +When a map or world is unloaded, DFHack looks for files of the form +``onMapUnload*.init`` or ``onUnload*.init``, respectively. -show ----- -Shows the terminal window after it has been `hidden `. -Only available on Windows. You'll need to use it from a -`keybinding` set beforehand, or the in-game `command-prompt`. +Modders often use unload init scripts to disable tools which should not run +after a modded save is unloaded. -.. _type: -type ----- -``type command`` shows where ``command`` is implemented. +.. _other_init_files: -Other Commands --------------- -The following commands are *not* built-in, but offer similarly useful functions. +init.d/\*.lua +............. -* `command-prompt` -* `hotkeys` -* `lua` -* `multicmd` -* `nopause` -* `quicksave` -* `rb` -* `repeat` +Any lua script named ``init.d/*.lua``, in the save or main DF directory, +will be run when any world or that save is loaded. -.. _init-files: +.. _script-paths: -Init Files -========== -DFHack allows users to automatically run commonly-used DFHack commands -when DF is first loaded, when a game is loaded, and when a game is unloaded. +Script paths +------------ -Init scripts function the same way they would if the user manually typed -in their contents, but are much more convenient. In order to facilitate -savegave portability, mod merging, and general organization of init files, -DFHack supports multiple init files both in the main DF directory and -save-specific init files in the save folders. +Script paths are folders that DFHack searches to find a script when a command is +run. By default, the following folders are searched, in order (relative to the +root DF folder): -DFHack looks for init files in three places each time they could be run: +#. :file:`dfhack-config/scripts` +#. :file:`save/{world}/scripts` (only if a save is loaded) +#. :file:`hack/scripts` +#. :file:`data/installed_mods/...` (see below) -#. The main DF directory -#. :file:`data/save/{world}/raw`, where ``world`` is the current save, and -#. :file:`data/save/{world}/raw/objects` +For example, if ``teleport`` is run, these folders are searched in order for +``teleport.lua``, and the first matching file is run. -When reading commands from dfhack.init or with the `script` command, if the final -character on a line is a backslash then the next uncommented line is considered a -continuation of that line, with the backslash deleted. Commented lines are skipped, -so it is possible to comment out parts of a command with the ``#`` character. +Scripts in installed mods +......................... +Scripts in mods are automatically added to the script path. The following +directories are searched for mods:: -.. _dfhack.init: + ../../workshop/content/975370/ (the DF Steam workshop directory) + mods/ + data/installed_mods/ -dfhack*.init ------------- -If your DF folder contains at least one file named ``dfhack*.init`` -(where ``*`` is a placeholder for any string), then all such files -are executed in alphabetical order when DF is first started. +Each mod can have two directories that contain scripts: -DFHack is distributed with :download:`/dfhack.init-example` as an example -with an up-to-date collection of basic commands; mostly setting standard -keybindings and `enabling ` plugins. You are encouraged to look -through this file to learn which features it makes available under which -key combinations. You may also customise it and rename it to ``dfhack.init``. +- ``scripts_modactive/`` is added to the script path if and only if the mod is + active in the loaded world. +- ``scripts_modinstalled/`` is added to the script path as long as the mod is + installed in one of the searched mod directories. -If your DF folder does not contain any ``dfhack*.init`` files, the example -will be run as a fallback. +Multiple versions of a mod may be installed at the same time. If a mod is +active in a loaded world, then the scripts for the version of the mod that is +active will be added to the script path. Otherwise, the latest version of each +mod is added to the script path. -These files are best used for keybindings and enabling persistent plugins -which do not require a world to be loaded. +Scripts for active mods take precedence according to their load order when you +generated the current world. +Scripts for non-active mods are ordered by their containing mod's ID. -.. _onLoad.init: +For example, the search paths for mods might look like this:: -onLoad*.init ------------- -When a world is loaded, DFHack looks for files of the form ``onLoad*.init``, -where ``*`` can be any string, including the empty string. + activemod_last_in_load_order/scripts_modactive + activemod_last_in_load_order/scripts_modinstalled + activemod_second_to_last_in_load_order/scripts_modactive + activemod_second_to_last_in_load_order/scripts_modinstalled + ... + inactivemod1/scripts_modinstalled + inactivemod2/scripts_modinstalled + ... -All matching init files will be executed in alphebetical order. -A world being loaded can mean a fortress, an adventurer, or legends mode. +Not all mods will have script directories, of course, and those mods will not be +added to the script search path. Mods are re-scanned whenever a world is loaded +or unloaded. For more information on scripts and mods, check out the +`modding-guide`. -These files are best used for non-persistent commands, such as setting -a `fix ` script to run on `repeat`. +Custom script paths +................... +Script paths can be added by modifying :file:`dfhack-config/script-paths.txt`. +Each line should start with one of these characters: -.. _onUnload.init: +- ``+``: adds a script path that is searched *before* the default paths (above) +- ``-``: adds a script path that is searched *after* the default paths +- ``#``: a comment (the line is ignored) -onUnload*.init --------------- -When a world is unloaded, DFHack looks for files of the form ``onUnload*.init``. -Again, these files may be in any of the above three places. -All matching init files will be executed in alphebetical order. +Paths can be absolute or relative - relative paths are interpreted relative to +the root DF folder. -Modders often use such scripts to disable tools which should not affect -an unmodded save. +.. admonition:: Tip -.. _other_init_files: + When developing scripts in the :source-scripts:`dfhack/scripts repo <>`, + it may be useful to add the path to your local copy of the repo with ``+``. + This will allow you to make changes in the repo and have them take effect + immediately, without needing to re-install or copy scripts over manually. -Other init files ----------------- +Note that ``script-paths.txt`` is only read at startup, but the paths can also be +modified programmatically at any time through the `Lua API `. -* ``onMapLoad*.init`` and ``onMapUnload*.init`` are run when a map, - distinct from a world, is loaded. This is good for map-affecting - commands (eg `clean`), or avoiding issues in Legends mode. +Commandline options +=================== -* Any lua script named ``raw/init.d/*.lua``, in the save or main DF - directory, will be run when any world or that save is loaded. +In addition to `Using an OS terminal`_ to execute commands on startup, DFHack +also recognizes a few commandline options. + +Options passed to Dwarf Fortress +-------------------------------- +These options can be passed to Dwarf Fortress and will be intercepted by +DFHack. If you are launching Dwarf Fortress from Steam, you can set your +options in the "Launch Options" text box in the properties for the Dwarf +Fortress app (**NOT the DFHack app**). Note that these launch options will be +used regardless of whether you run Dwarf Fortress from its own app or DFHack's. + +- ``--disable-dfhack``: If set, then DFHack will be disabled for the session. + You will have to restart Dwarf Fortress without specifying this option in + order to use DFHack. Note that even if DFHack is disabled, :file:`stdout.txt` + and :file:`stderr.txt` will still be redirected to :file:`stdout.log` and + :file:`stderr.log`, respectively. + +- ``--nosteam-dfhack``: If set, then the DFHack stub launcher will not execute + when you launch DF from its own app in the Steam client. This will prevent + your settings from being restored or backed up with Steam Cloud Save. This is + probably not what you want. If you want to just not have the DFHack playtime + counted towards your hours, see the DFHack stub launcher ``--nowait`` option + below. + +- ``--skip-size-check``: DFHack normally verifies the sizes of important game + on startup and shuts down if a discrepancy is detected. This is intended to + reduce the risk of misalignments in these structures leading to crashes or + other misbehavior. This option bypasses the check. This option should + normally only be used to facilitate DFHack development. This option will + **not** enable DFHack to be used usefully with a version of DF with which + DFHack has not been aligned. + +Options passed to the DFHack Steam stub launcher +------------------------------------------------ + +These options can be passed to the DFHack stub launcher that executes when you +run the DFHack app from the Steam client. You can set your options in the +"Launch Options" text box in the properties for the DFHack app (**NOT the Dwarf +Fortress app**). Note that these launch options will be used regardless of +whether you run Dwarf Fortress from its own app or DFHack's. + +- ``--nowait``: If set, the DFHack stub launcher will not wait for DF to exit + before exiting itself. This may be desired by players who do not want their + playtime "double counted". However, using this option means that your DFHack + settings that get backed up to the cloud will always be out of sync. The stub + launcher normally downloads updated settings from Steam Cloud Save when DF + launches, and then backs up changed settings when DF exits. If this option is + used, then your settings will still be reconciled when DF launches, but + changes made during your play session will not be saved when DF exits. Please + use with caution -- you may lose data. + +.. _env-vars: + +Environment variables +===================== + +DFHack's behavior can be adjusted with some environment variables. For example, +on UNIX-like systems: + +.. code-block:: shell + + DFHACK_SOME_VAR=1 ./dfhack + +- ``DFHACK_DISABLE``: if set, DFHack will not initialize, not even to redirect + standard output or standard error. This is provided as an alternative + to the ``--disable-dfhack`` commandline parameter above for when environment + variables are more convenient. + +- ``DFHACK_PORT``: the port to use for the RPC server (used by ``dfhack-run`` + and `remotefortressreader` among others) instead of the default ``5000``. As + with the default, if this port cannot be used, the server is not started. + See `remote` for more details. + +- ``DFHACK_DISABLE_CONSOLE``: if set, DFHack's external console is not set up. + This is the default behavior if ``PRINT_MODE:TEXT`` is set in + ``data/init/init.txt``. Intended for situations where DFHack cannot run in a + terminal window. + +- ``DFHACK_HEADLESS``: if set, and ``PRINT_MODE:TEXT`` is set, DF's display will + be hidden, and the console will be started unless ``DFHACK_DISABLE_CONSOLE`` + is also set. Intended for non-interactive gameplay only. + +- ``DFHACK_NO_GLOBALS``, ``DFHACK_NO_VTABLES``: ignores all global or vtable + addresses in ``symbols.xml``, respectively. Intended for development use - + e.g. to make sure tools do not crash when these addresses are missing. + +- ``DFHACK_NO_DEV_PLUGINS``: if set, any plugins from the plugins/devel folder + that are built and installed will not be loaded on startup. + +- ``DFHACK_LOG_MEM_RANGES`` (macOS only): if set, logs memory ranges to + ``stderr.log``. Note that `devel/lsmem` can also do this. + +- ``DFHACK_ENABLE_LUACOV``: if set, enables coverage analysis of Lua scripts. + Use the `devel/luacov` script to generate coverage reports from the collected + metrics. + +Other (non-DFHack-specific) variables that affect DFHack: + +- ``TERM``: if this is set to ``dumb`` or ``cons25`` on \*nix, the console will + not support any escape sequences (arrow keys, etc.). + +- ``LANG``, ``LC_CTYPE``: if either of these contain "UTF8" or "UTF-8" (not case + sensitive), ``DF2CONSOLE()`` will produce UTF-8-encoded text. Note that this + should be the case in most UTF-8-capable \*nix terminal emulators already. + +Core preferences +================ + +Settings that control DFHack's runtime behavior can be changed dynamically via +the "Preferences" tab in `gui/control-panel` or on the commandline with +`control-panel`. The two most important settings for the core are: + +- ``HIDE_CONSOLE_ON_STARTUP``: On Windows, this controls whether to hide the + external DFHack terminal window on startup. The console is hidden by default + so it does not get in the way of gameplay, but it can be useful to enable for + debugging purposes or if you just prefer to use the external console instead + of the in-game `gui/launcher`. When you change this setting, the new behavior + will take effect the next time you start the game. If you are running the + native Linux version of DF (and DFHack), the terminal that you run the game + from becomes the DFHack console and this setting has no effect. -Miscellaneous Notes -=================== -This section is for odd but important notes that don't fit anywhere else. +- ``HIDE_ARMOK_TOOLS``: Whether to hide "armok" tools in command lists. Also + known as "Mortal mode", this setting keeps god-mode tools out of sight and + out of mind. Highly recommended for players who would prefer if the god-mode + tools were not quite as obvious and accessible. -* The ``dfhack-run`` executable is there for calling DFHack commands in - an already running DF+DFHack instance from external OS scripts and programs, - and is *not* the way how you use DFHack normally. +.. _performance-monitoring: -* If a DF :kbd:`H` hotkey is named with a DFHack command, pressing - the corresponding :kbd:`Fx` button will run that command, instead of - zooming to the set location. +Performance monitoring +====================== -* The command line has some nice line editing capabilities, including history - that's preserved between different runs of DF (use up/down keys to go through - the history). +Though DFHack tools are generally performant, they do take some amount of time +to run. DFHack tracks its impact on DF game speed so the DFHack team can be +aware of (and fix) tools that are taking more than their fair share of +processing time. -* The binaries for 0.40.15-r1 to 0.34.11-r4 are on DFFD_. - Older versions are available here_. +The target threshold for DFHack CPU utilization during unpaused gameplay with +all overlays and automation tools enabled is 10%. This is about the level where +players would notice the impact. In general, DFHack will have even less impact +for most players, since it is not common for every single DFHack tool to be +enabled at once. - .. _DFFD: http://dffd.bay12games.com/search.php?string=DFHack&id=15&limit=1000 - .. _here: http://dethware.org/dfhack/download +DFHack will record a performance report with the savegame files named +``dfhack-perf-counters.dat``. The report contains measurements from when the +game was loaded to the time when it was saved. By default, only unpaused time is +measured (since processing done while the game is paused doesn't slow anything +down from the player's perspective). You can display a live report at any time +by running:: -* To include whitespace in the argument/s to some command, quote it in - double quotes. To include a double quote character, use ``\"``. + :lua require('script-manager').print_timers() -* If the first non-whitespace character is ``:``, the command is parsed in - an alternative mode which is very useful for the `lua` and `rb` commands. - The following two command lines are exactly equivalent:: +You can reset the timers to start a new measurement session by running:: - :foo a b "c d" e f - foo "a b \"c d\" e f" + :lua dfhack.internal.resetPerfCounters() - * non-whitespace characters following the ``:`` are the command name - * the remaining part of the line is used verbatim as the first argument +If you want to record performance over all elapsed time, not just unpaused +time, then instead run:: + :lua dfhack.internal.resetPerfCounters(true) diff --git a/docs/History.rst b/docs/History.rst deleted file mode 100644 index b399fbbddf..0000000000 --- a/docs/History.rst +++ /dev/null @@ -1,605 +0,0 @@ -:orphan: - -.. _HISTORY: - -######################## -HISTORY - old changelogs -######################## - -This file is where old changelogs live, so the current `changelog` -in ``NEWS.rst`` doesn't get too long. - -.. contents:: - :depth: 2 - - -DFHack 0.40.23-r1 -================= - -Internals -- plugins will not be loaded if globals they specify as required are not located (should prevent some crashes) - -Fixes ------ -- Fixed numerous (mostly Lua-related) crashes on OS X by including a more up-to-date libstdc++ -- :kbd:`Alt` should no longer get stuck on Windows (and perhaps other platforms as well) -- `gui/advfort` works again -- `autobutcher`: takes sexualities into account -- devel/export-dt-ini: Updated for 0.40.20+ -- `digfort`: now checks file type and existence -- `exportlegends`: Fixed map export -- `full-heal`: Fixed a problem with selecting units in the GUI -- `gui/hack-wish`: Fixed restrictive material filters -- `mousequery`: Changed box-select key to Alt+M -- `dwarfmonitor`: correct date display (month index, separator) -- `putontable`: added to the readme -- `siren` should work again -- stderr.log: removed excessive debug output on OS X -- `trackstop`: No longer prevents cancelling the removal of a track stop or roller. -- Fixed a display issue with ``PRINT_MODE:TEXT`` -- Fixed a symbol error (MapExtras::BiomeInfo::MAX_LAYERS) when compiling DFHack in Debug mode - -New Plugins ------------ -- `fortplan`: designate construction of (limited) buildings from .csv file, quickfort-style - -New Scripts ------------ -- `gui/stockpiles`: an in-game interface for saving and loading stockpile settings files. -- `position`: Reports the current date, time, month, and season, plus some location info. Port/update of position.py -- `hfs-pit`: Digs a hole to hell under the cursor. Replaces needs_porting/hellhole.cpp - -Removed -------- -- embark.lua: Obsolete, use `embark-tools` - -New tweaks ----------- -- `eggs-fertile `: Displays an egg fertility indicator on nestboxes -- `max-wheelbarrow `: Allows assigning more than 3 wheelbarrows to a stockpile - -Misc Improvements ------------------ -- `embark-tools`: Added basic mouse support on the local map -- Made some adventure mode keybindings in :file:`dfhack.init-example` only work in adventure mode -- `gui/companion-order`: added a default keybinding -- further work on needs_porting - - -DFHack 0.40.19-r1 -================= - -Fixes ------ -- `modtools/reaction-trigger`: fixed typo -- `modtools/item-trigger`: should now work with item types - -New plugins ------------ -- `savestock, loadstock `: save and load stockpile settings across worlds and saves - -New scripts ------------ -- `remove-stress`: set selected or all units unit to -1,000,000 stress (this script replaces removebadthoughts) - -Misc improvements ------------------ -- `command-prompt`: can now access selected items, units, and buildings -- `autolabor`: add an optional talent pool parameter - - -DFHack 0.40.16-r1 -================= - -Internals ---------- -- `EventManager` should handle INTERACTION triggers a little better. It still can get confused about who did what but only rarely. -- `EventManager` should no longer trigger REPORT events for old reports after loading a save. -- lua/persist-table: a convenient way of using persistent tables of arbitrary structure and dimension in Lua - -Fixes ------ -- `mousequery`: Disabled when linking levers -- `stocks`: Melting should work now -- `full-heal`: Updated with proper argument handling -- `modtools/reaction-trigger-transition`: should produce the correct syntax now -- `superdwarf`: should work better now -- `forum-dwarves`: update for new df-structures changes - -New Scripts ------------ -- `adaptation`: view or set the cavern adaptation level of your citizens -- `add-thought`: allows the user to add thoughts to creatures. -- `gaydar`: detect the sexual orientation of units on the map -- `markdown`: Save a copy of a text screen in markdown (for reddit among others). -- devel/all-bob: renames everyone Bob to help test interaction-trigger - -Misc Improvements ------------------ -- `autodump`: Can now mark a stockpile for auto-dumping (similar to `automelt` and `autotrade`) -- `buildingplan`: Can now auto-allocate rooms to dwarves with specific positions (e.g. expedition leader, mayor) -- `dwarfmonitor`: now displays a weather indicator and date -- lua/syndrome-util, `modtools/add-syndrome`: now you can remove syndromes by SYN_CLASS -- No longer write empty :file:`.history` files - - -DFHack 0.40.15-r1 -================= - -Fixes ------ -- mousequery: Fixed behavior when selecting a tile on the lowest z-level - -Misc Improvements ------------------ -- `EventManager`: deals with frame_counter getting reset properly now. -- `modtools/item-trigger`: fixed equip/unequip bug and corrected minor documentation error -- `teleport`: Updated with proper argument handling and proper unit-at-destination handling. -- `autotrade`: Removed the newly obsolete :guilabel:`Mark all` functionality. -- `search-plugin`: Adapts to the new trade screen column width -- `tweak fast-trade `: Switching the fast-trade keybinding to Shift-Up/Shift-Down, due to Select All conflict - - -DFHack 0.40.14-r1 -================= - -Internals ---------- -- The DFHack console can now be disabled by setting the DFHACK_DISABLE_CONSOLE environment variable: ``DFHACK_DISABLE_CONSOLE=1 ./dfhack`` - -Fixes ------ -- Stopped duplicate load/unload events when unloading a world -- Stopped ``-e`` from being echoed when DFHack quits on Linux -- `automelt`: now uses a faster method to locate items -- `autotrade`: "Mark all" no longer double-marks bin contents -- `drain-aquifer`: new script replaces the buggy plugin -- `embark-tools`: no longer conflicts with keys on the notes screen -- `fastdwarf`: Fixed problems with combat/attacks -- `forum-dwarves`: should work now -- `manipulator`: now uses a stable sort, allowing sorting by multiple categories -- `rendermax`: updated to work with 0.40 - -New Plugins ------------ -- `trackstop`: Shows track stop friction and dump direction in its :kbd:`q` menu - -New Tweaks ----------- -- farm-plot-select: Adds "Select all" and "Deselect all" options to farm plot menus -- import-priority-category: Allows changing the priority of all goods in a category when discussing an import agreement with the liaison -- manager-quantity: Removes the limit of 30 jobs per manager order -- civ-view-agreement: Fixes overlapping text on the "view agreement" screen -- nestbox-color: Fixes the color of built nestboxes - -Misc Improvements ------------------ -- `exportlegends`: can now handle site maps - - -DFHack 0.40.13-r1 -================= - -Internals ---------- -- unified spatter structs -- added ruby df.print_color(color, string) method for dfhack console - -Fixes ------ -- no more ``-e`` after terminating -- fixed `superdwarf` - - -DFHack 0.40.12-r1 -================= - -Internals ---------- -- support for global `onLoad.init` and `onUnload.init` files, called when loading and unloading a world -- Close file after loading a `binary patch `. - -New Plugins ------------ -- `hotkeys`: Shows ingame viewscreen with all dfhack keybindings active in current mode. -- `automelt`: allows marking stockpiles so any items placed in them will be designated for melting - -Fixes ------ -- possible crash fixed for `gui/hack-wish` -- `search-plugin`: updated to not conflict with BUILDJOB_SUSPEND -- `workflow`: job_material_category -> dfhack_material_category - -Misc Improvements ------------------ -- now you can use ``@`` to print things in interactive Lua with subtley different semantics -- optimizations for stockpiles for `autotrade` and `stockflow` -- updated `exportlegends` to work with new maps, dfhack 40.11 r1+ - - -DFHack 0.40.11-r1 -================= - -Internals -- Plugins on OS X now use ``.plug.dylib` as an extension instead of ``.plug.so`` - -Fixes ------ -- `3dveins`: should no longer hang/crash on specific maps -- `autotrade`, `search-plugin`: fixed some layout issues -- `deathcause`: updated -- `gui/hack-wish`: should work now -- `reveal`: no longer allocates data for nonexistent map blocks -- Various documentation fixes and updates - - -DFHack v0.40.10-r1 -================== - -A few bugfixes. - -DFHack v0.40.08-r2 -================== - -Internals ---------- -- supported per save script folders -- Items module: added createItem function -- Sorted CMakeList for plugins and plugins/devel -- `diggingInvaders` no longer builds if plugin building is disabled -- `EventManager`: EQUIPMENT_CHANGE now triggers for new units. New events:: - - ON_REPORT - UNIT_ATTACK - UNLOAD - INTERACTION - -New Scripts ------------ -- lua/repeat-util: makes it easier to make things repeat indefinitely -- lua/syndrome-util: makes it easier to deal with unit syndromes -- `forum-dwarves`: helps copy df viewscreens to a file -- `full-heal`: fully heal a unit -- `remove-wear`: removes wear from all items in the fort -- `repeat`: repeatedly calls a script or a plugin -- ShowUnitSyndromes: shows syndromes affecting units and other relevant info -- `teleport`: teleports units -- `devel/print-args` -- `fix/blood-del`: makes it so civs don't bring barrels full of blood ichor or goo -- `fix/feeding-timers`: reset the feeding timers of all units -- `gui/hack-wish`: creates items out of any material -- `gui/unit-info-viewer`: displays information about units -- `modtools/add-syndrome`: add a syndrome to a unit or remove one -- `modtools/anonymous-script`: execute an lua script defined by a string. Useful for the ``*-trigger`` scripts. -- `modtools/force`: forces events: caravan, migrants, diplomat, megabeast, curiousbeast, mischievousbeast, flier, siege, nightcreature -- `modtools/item-trigger`: triggers commands based on equipping, unequipping, and wounding units with items -- `modtools/interaction-trigger`: triggers commands when interactions happen -- `modtools/invader-item-destroyer`: destroys invaders' items when they die -- `modtools/moddable-gods`: standardized version of Putnam's moddable gods script -- `modtools/projectile-trigger`: standardized version of projectileExpansion -- `modtools/reaction-trigger`: trigger commands when custom reactions complete; replaces autoSyndrome -- `modtools/reaction-trigger-transition`: a tool for converting mods from autoSyndrome to reaction-trigger -- `modtools/random-trigger`: triggers random scripts that you register -- `modtools/skill-change`: for incrementing and setting skills -- `modtools/spawn-flow`: creates flows, like mist or dragonfire -- `modtools/syndrome-trigger`: trigger commands when syndromes happen -- `modtools/transform-unit`: shapeshifts a unit, possibly permanently - -Misc improvements ------------------ -- new function in utils.lua for standardized argument processing - -Removed -------- -- digmat.rb: digFlood does the same functionality with less FPS impact -- invasionNow: `modtools/force` does it better -- autoSyndrome replaced with `modtools/reaction-trigger` -- syndromeTrigger replaced with `modtools/syndrome-trigger` -- devel/printArgs plugin converted to `devel/print-args` -- outsideOnly plugin replaced by `modtools/outside-only` - - -DFHack v0.40.08-r1 -================== - -Was a mistake. Don't use it. - -DFHack v0.34.11-r5 -================== - -Internals ---------- -- support for calling a lua function via a protobuf request (demonstrated by dfhack-run --lua). -- support for basic filesystem operations (e.g. chdir, mkdir, rmdir, stat) in C++ and Lua -- Lua API for listing files in directory. Needed for `gui/mod-manager` -- Lua API for creating unit combat reports and writing to gamelog. -- Lua API for running arbitrary DFHack commands -- support for multiple ``raw/init.d/*.lua`` init scripts in one save. -- eventful now has a more friendly way of making custom sidebars -- on Linux and OS X the console now supports moving the cursor back and forward by a whole word. - -New scripts ------------ -- `gui/mod-manager`: allows installing/uninstalling mods into df from ``df/mods`` directory. -- `gui/clone-uniform`: duplicates the currently selected uniform in the military screen. -- `fix/build-location`: partial work-around for :bug:`5991` (trying to build wall while standing on it) -- `undump-buildings`: removes dump designation from materials used in buildings. -- `exportlegends`: exports data from legends mode, allowing a set-and-forget export of large worlds. -- log-region: each time a fort is loaded identifying information will be written to the gamelog. -- `dfstatus `: show an overview of critical stock quantities, including food, drinks, wood, and bars. -- `command-prompt`: a dfhack command prompt in df. - -New plugins ------------ -- `rendermax`: replace the renderer with something else, eg ``rendermax light``- a lighting engine -- `automelt`: allows marking stockpiles for automelt (i.e. any items placed in stocpile will be designated for melting) -- `embark-tools`: implementations of Embark Anywhere, Nano Embark, and a few other embark-related utilities -- `building-hacks`: Allows to add custom functionality and/or animations to buildings. -- `petcapRemover`: triggers pregnancies in creatures so that you can effectively raise the default pet population cap -- `plant create `: spawn a new shrub under the cursor - -New tweaks ----------- -- craft-age-wear: make crafted items wear out with time like in old versions (:bug:`6003`) -- adamantine-cloth-wear: stop adamantine clothing from wearing out (:bug:`6481`) -- confirm-embark: adds a prompt before embarking (on the "prepare carefully" screen) - -Misc improvements ------------------ -- `plant`: move the 'grow', 'extirpate' and 'immolate' commands as 'plant' subcommands -- `digfort`: improved csv parsing, add start() comment handling -- `exterminate`: allow specifying a caste (exterminate gob:male) -- `createitem`: in adventure mode it now defaults to the controlled unit as maker. -- `autotrade`: adds "(Un)mark All" options to both panes of trade screen. -- `mousequery`: several usability improvements; show live overlay (in menu area) of what's on the tile under the mouse cursor. -- `search`: workshop profile search added. -- `dwarfmonitor`: add screen to summarise preferences of fortress dwarfs. -- `getplants`: add autochop function to automate woodcutting. -- `stocks`: added more filtering and display options. - -- `siege-engine`: - - - engine quality and distance to target now affect accuracy - - firing the siege engine at a target produces a combat report - - improved movement speed computation for meandering units - - operators in Prepare To Fire mode are released from duty once hungry/thirsty if there is a free replacement - - -DFHack v0.34.11-r4 -================== - -New commands ------------- -- `diggingInvaders` - allows invaders to dig and/or deconstruct walls and buildings in order to get at your dwarves. -- `digFlood` - automatically dig out specified veins as they are revealed -- `enable, disable ` - Built-in commands that can be used to enable/disable many plugins. -- `restrictice` - Restrict traffic on squares above visible ice. -- `restrictliquids` - Restrict traffic on every visible square with liquid. -- treefarm - automatically chop trees and dig obsidian - -New Scripts ------------ -- `autobutcher`: A GUI front-end for the autobutcher plugin. -- invasionNow: trigger an invasion, or many -- `locate-ore`: scan the map for unmined ore veins -- `masspit`: designate caged creatures in a zone for pitting -- `multicmd`: run a sequence of dfhack commands, separated by ';' -- `startdwarf`: change the number of dwarves for a new embark -- digmat: dig veins/layers tile by tile, as discovered - -Misc improvements ------------------ -- autoSyndrome: - - - disable by default - - reorganized special tags - - minimized error spam - - reset policies: if the target already has an instance of the syndrome you can skip, - add another instance, reset the timer, or add the full duration to the time remaining - -- core: fix SC_WORLD_(UN)LOADED event for arena mode -- `exterminate`: renamed from slayrace, add help message, add butcher mode -- `fastdwarf`: fixed bug involving fastdwarf and teledwarf being on at the same time -- magmasource: rename to `source`, allow water/magma sources/drains -- Add df.dfhack_run "somecommand" to Ruby -- syndromeTrigger: replaces and extends trueTransformation. Can trigger things when syndromes are added for any reason. -- `tiletypes`: support changing tile material to arbitrary stone. -- `workNow`: can optionally look for jobs when jobs are completed - -New tweaks ----------- -- hive-crash: Prevent crash if bees die in a hive with ungathered products (:bug:`6368`). - -New plugins ------------ -- `3dveins`: Reshapes all veins on the map in a way that flows between Z levels. May be unstable. Backup before using. -- `autotrade`: Automatically send items in marked stockpiles to trade depot, when trading is possible. -- `buildingplan`: Place furniture before it's built -- `dwarfmonitor`: Records dwarf activity to measure fort efficiency -- `mousequery`: Look and poke at the map elements with the mouse. -- outsideOnly: make raw-specified buildings impossible to build inside -- `resume`: A plugin to help display and resume suspended constructions conveniently -- `stocks`: An improved stocks display screen. - -Internals ---------- -- Core: there is now a per-save dfhack.init file for when the save is loaded, and another for when it is unloaded -- EventManager: fixed job completion detection, fixed removal of TICK events, added EQUIPMENT_CHANGE event -- Lua API for a better `random number generator ` and perlin noise functions. -- Once: easy way to make sure something happens once per run of DF, such as an error message - - -DFHack v0.34.11-r3 -================== - -Internals ---------- -- support for displaying active keybindings properly. -- support for reusable widgets in lua screen library. -- Maps::canStepBetween: returns whether you can walk between two tiles in one step. -- EventManager: monitors various in game events centrally so that individual plugins - don't have to monitor the same things redundantly. -- Now works with OS X 10.6.8 - -Notable bugfixes ----------------- -- `autobutcher` can be re-enabled again after being stopped. -- stopped `Dwarf Manipulator ` from unmasking vampires. -- `stonesense` is now fixed on OS X - -Misc improvements ------------------ -- `fastdwarf`: new mode using debug flags, and some internal consistency fixes. -- added a small stand-alone utility for applying and removing `binary patches `. -- removebadthoughts: add --dry-run option -- `superdwarf`: work in adventure mode too -- `tweak` stable-cursor: carries cursor location from/to Build menu. -- `deathcause`: allow selection from the unitlist screen -- slayrace: allow targetting undeads -- `workflow` plugin: - - - properly considers minecarts assigned to routes busy. - - code for deducing job outputs rewritten in lua for flexibility. - - logic fix: collecting webs produces silk, and ungathered webs are not thread. - - items assigned to squads are considered busy, even if not in inventory. - - shearing and milking jobs are supported, but only with generic MILK or YARN outputs. - - workflow announces when the stock level gets very low once a season. - -- Auto syndrome plugin: A way of automatically applying boiling rock syndromes and calling dfhack commands controlled by raws. -- `infiniteSky` plugin: Create new z-levels automatically or on request. -- True transformation plugin: A better way of doing permanent transformations that allows later transformations. -- `workNow` plugin: Makes the game assign jobs every time you pause. - -New tweaks ----------- -- tweak military-training: speed up melee squad training up to 10x (normally 3-5x). - -New scripts ------------ -- `binpatch`: the same as the stand-alone binpatch.exe, but works at runtime. -- region-pops: displays animal populations of the region and allows tweaking them. -- `lua`: lua interpreter front-end converted to a script from a native command. -- dfusion: misc scripts with a text based menu. -- embark: lets you embark anywhere. -- `lever`: list and pull fort levers from the dfhack console. -- `stripcaged`: mark items inside cages for dumping, eg caged goblin weapons. -- soundsense-season: writes the correct season to gamelog.txt on world load. -- create-items: spawn items -- fix/cloth-stockpile: fixes :bug:`5739`; needs to be run after savegame load every time. - -New GUI scripts ---------------- -- `gui/guide-path`: displays the cached path for minecart Guide orders. -- `gui/workshop-job`: displays inputs of a workshop job and allows tweaking them. -- `gui/workflow`: a front-end for the workflow plugin (part inspired by falconne). -- `gui/assign-rack`: works together with a binary patch to fix weapon racks. -- `gui/gm-editor`: an universal editor for lots of dfhack things. -- `gui/companion-order`: a adventure mode command interface for your companions. -- `gui/advfort`: a way to do jobs with your adventurer (e.g. build fort). - -New binary patches ------------------- -(for use with `binpatch`) - -- armorstand-capacity: doubles the capacity of armor stands. -- custom-reagent-size: lets custom reactions use small amounts of inputs. -- deconstruct-heapfall: stops some items still falling on head when deconstructing. -- deconstruct-teleport: stops items from 16x16 block teleporting when deconstructing. -- hospital-overstocking: stops hospital overstocking with supplies. -- training-ammo: lets dwarves with quiver full of combat-only ammo train. -- weaponrack-unassign: fixes bug that negates work done by gui/assign-rack. - -New Plugins ------------ -- `fix-armory`: Together with a couple of binary patches and the `gui/assign-rack` script, this plugin makes weapon racks, armor stands, chests and cabinets in properly designated barracks be used again for storage of squad equipment. -- `search`: Adds an incremental search function to the Stocks, Trading, Stockpile and Unit List screens. -- `automaterial`: Makes building constructions (walls, floors, fortifications, etc) a little bit easier by saving you from having to trawl through long lists of materials each time you place one. -- Dfusion: Reworked to make use of lua modules, now all the scripts can be used from other scripts. -- Eventful: A collection of lua events, that will allow new ways to interact with df world. - -DFHack v0.34.11-r2 -================== - -Internals ---------- -- full support for Mac OS X. -- a plugin that adds scripting in `ruby `. -- support for interposing virtual methods in DF from C++ plugins. -- support for creating new interface screens from C++ and lua. -- added various other API functions. - -Notable bugfixes ----------------- -- better terminal reset after exit on linux. -- `seedwatch` now works on reclaim. -- the sort plugin won't crash on cages anymore. - -Misc improvements ------------------ -- `autodump`: can move items to any walkable tile, not just floors. -- `stripcaged`: by default keep armor, new dumparmor option. -- `zone`: allow non-domesticated birds in nestboxes. -- `workflow`: quality range in constraints. -- cleanplants: new command to remove rain water from plants. -- `liquids`: can paint permaflow, i.e. what makes rivers power water wheels. -- `prospect`: pre-embark prospector accounts for caves & magma sea in its estimate. -- `rename`: supports renaming stockpiles, workshops, traps, siege engines. -- `fastdwarf`: now has an additional option to make dwarves teleport to their destination. -- `autolabor`: - - - can set nonidle hauler percentage. - - broker excluded from all labors when needed at depot. - - likewise, anybody with a scheduled diplomat meeting. - -New commands ------------- -- misery: multiplies every negative thought gained (2x by default). -- `digtype`: designates every tile of the same type of vein on the map for 'digging' (any dig designation). - -New tweaks ----------- -- tweak stable-cursor: keeps exact cursor position between d/k/t/q/v etc menus. -- tweak patrol-duty: makes Train orders reduce patrol timer, like the binary patch does. -- tweak readable-build-plate: fix unreadable truncation in unit pressure plate build ui. -- tweak stable-temp: fixes bug 6012; may improve FPS by 50-100% on a slow item-heavy fort. -- tweak fast-heat: speeds up item heating & cooling, thus making stable-temp act faster. -- tweak fix-dimensions: fixes subtracting small amounts from stacked liquids etc. -- tweak advmode-contained: fixes UI bug in custom reactions with container inputs in advmode. -- tweak fast-trade: Shift-Enter for selecting items quckly in Trade and Move to Depot screens. -- tweak military-stable-assign: Stop rightmost list of military->Positions from jumping to top. -- tweak military-color-assigned: In same list, color already assigned units in brown & green. - -New scripts ------------ -- `fixnaked`: removes thoughts about nakedness. -- `setfps`: set FPS cap at runtime, in case you want slow motion or speed-up. -- `siren`: wakes up units, stops breaks and parties - but causes bad thoughts. -- `fix/population-cap`: run after every migrant wave to prevent exceeding the cap. -- `fix/stable-temp`: counts items with temperature updates; does instant one-shot stable-temp. -- `fix/loyaltycascade`: fix units allegiance, eg after ordering a dwarf merchant kill. -- `deathcause`: shows the circumstances of death for a given body. -- `digfort`: designate areas to dig from a csv file. -- `drain-aquifer`: remove aquifers from the map. -- `growcrops`: cheat to make farm crops instantly grow. -- magmasource: continuously spawn magma from any map tile. -- removebadthoughts: delete all negative thoughts from your dwarves. -- slayrace: instakill all units of a given race, optionally with magma. -- `superdwarf`: per-creature `fastdwarf`. -- `gui/mechanisms`: browse mechanism links of the current building. -- `gui/room-list`: browse other rooms owned by the unit when assigning one. -- `gui/liquids`: a GUI front-end for the liquids plugin. -- `gui/rename`: renaming stockpiles, workshops and units via an in-game dialog. -- `gui/power-meter`: front-end for the Power Meter plugin. -- `gui/siege-engine`: front-end for the Siege Engine plugin. -- `gui/choose-weapons`: auto-choose matching weapons in the military equip screen. - -New Plugins ------------ -- `manipulator`: a Dwarf Therapist like UI in the game (:kbd:`u`:kbd:`l`) -- `steam-engine`: an alternative to Water Reactors which make more sense. - See ``hack/raw/*_steam_engine.txt`` for the necessary raw definitions. -- `power-meter`: a pressure plate modification to detect powered gear - boxes on adjacent tiles. `gui/power-meter` implements - the build configuration UI. -- `siege-engine`: massive overhaul for siege engines, configured via `gui/siege-engine` -- `add-spatter`: allows poison coatings via raw reactions, among other things. diff --git a/docs/Installing.rst b/docs/Installing.rst new file mode 100644 index 0000000000..a687498e7e --- /dev/null +++ b/docs/Installing.rst @@ -0,0 +1,174 @@ +.. _installing: + +========== +Installing +========== + +.. contents:: + :local: + +Requirements +============ + +DFHack supports all operating systems and platforms that Dwarf Fortress itself +supports, which at the moment is the 64-bit versions of Windows and Linux. +The Windows build of DFHack also works well under ``wine`` for platforms that +can't run a native version. When running via ``wine``, use the following commandline:: + + wine64 explorer Dwarf\ Fortress.exe + +.. _installing-df-version: + +DFHack releases generally only support the version of Dwarf Fortress that they +are named after. For example, DFHack 50.05 only supported DF 50.05. DFHack +releases *never* support newer versions of DF -- DFHack requires data about DF +that is only possible to obtain after DF has been released. Occasionally, +DFHack releases will be able to maintain support for older versions of DF - for +example, DFHack 0.34.11-r5 supported both DF 0.34.11 and 0.34.10. For maximum +stability, you should use the latest versions of both DF and DFHack. + +.. _downloading: + +Downloading DFHack +================== + +Stable builds of DFHack are available on +`Steam `__ +or from our `GitHub `__. Either +location will give you exactly the same package. + +On Steam, note that DFHack is a separate app, not a DF Steam Workshop mod. You +can run DF with DFHack by launching either the DFHack app or the original Dwarf +Fortress app. + +Even if you have a non-Steam version of DF (i.e. Itch or Classic), you can +still install DFHack from Steam to get the benefits of automatic updates and +Steam cloud backups. In this case, install DFHack from Steam and then move your +DF installation into the Steam-created ``Dwarf Fortress`` directory. You have +to run DF via the DFHack app in the Steam client in order to benefit from the +Steam cloud backup features. + +If you download from GitHub, downloads are available at the bottom of the +release notes for each release, under a section named "Assets" (which you may +have to expand). The name of the file indicates which DF version, platform, and +architecture the build supports - the platform and architecture (64-bit or +32-bit) **must** match your build of DF. The DF version should also match your +DF version - see `above ` for details. For example: + +* ``dfhack-50.07-r1-Windows-64bit.zip`` supports 64-bit DF on Windows + +.. warning:: + + Do *not* download the source code from GitHub, either from the releases page + or by clicking "Download ZIP" on the repo homepage. This will give you an + incomplete copy of the DFHack source code, which will not work as-is. (If + you want to compile DFHack instead of using a pre-built release, please see + `building-dfhack-index` for instructions.) + +Beta releases +------------- + +In between stable releases, we may create beta releases to test new features. +These are available via the ``beta`` release channel on Steam or from our +regular Github page as a pre-release tagged with a "beta" or "rc" ("release +candidate") suffix. + +Development builds +------------------ + +If you are actively working with the DFHack team on testing a feature, you may +want to download and install a development build. They are available via the +``testing`` release channel on Steam or can be downloaded from the build +artifact list on GitHub for specific repository commits. + +To download a development build from GitHub: + +- Ensure you are logged into your GitHub account +- Go to https://github.com/DFHack/dfhack/actions/workflows/build.yml?query=branch%3Adevelop+event%3Apush+is%3Asuccess +- Click on the first entry (it should have a green checkmark next to it) +- Click the number under "Artifacts" (or scroll down) +- Click on the ``dfhack-*-build-*`` artifact for your platform to download + +The artifacts are "double-zipped". That is, you will have to extract the +initial zip file to get to the package archive. You can extract this second +package the same as if you are doing a manual install (see the next section). + +Older releases +-------------- + +If you are downloading DFHack for very old versions of DF, the binaries for +0.40.15-r1 to 0.34.11-r4 are on DFFD_. Even older versions are available here_. + +.. _DFFD: https://dffd.bay12games.com/search.php?string=DFHack&id=15&limit=1000 +.. _here: https://dethware.org/dfhack/download + +Installing DFHack +================= + +If you are installing from Steam, this is handled for you automatically. The +instructions here are for manual installs. + +When you `download DFHack `, you will end up with a release archive +(a ``.zip`` file on Windows, or a ``.tar.bz2`` file on other platforms). Your +operating system should have built-in utilities capable of extracting files from +these archives. + +.. note:: + + If you are on Windows, please remember to right click on the file after + downloading, open the file properties, and select the "Unblock" checkbox. + This will prevent issues with Windows antivirus programs. + +The release archives contain a ``hack`` folder where DFHack binary and system +data is stored, a ``stonesense`` folder that contains data specific to the +`stonesense` 3d renderer, and various libraries and executable files. To +install DFHack, copy all of the files from the DFHack archive into the root DF +folder, which should already include a ``data`` folder and a ``save`` folder, +among other things. Some redistributions of Dwarf Fortress may place DF in +another folder, so ensure that the ``hack`` folder ends up next to the ``data`` +folder, and you'll be fine. + +Installing into a wineskin on Mac +--------------------------------- + +Until DF (and DFHack) is natively available for Mac, you'll have to run the +Windows version under emulation. Here are the instructions for adding DFHack to +a wineskin that has DF installed in it: + +#. Find the location of your existing Dwarf Fortress app (default is + ``/user/applications/Wineskin/``). Control + click and select "Show package + contents" from the menu. +#. Find the location of the ``Dwarf Fortress`` folder inside the package + contents (default is ``/drive_c/Program Files/``) +#. Copy the contents of the unzipped DFHack folder (Windows version) into the + ``Dwarf Fortress`` folder inside the package. + +These instructions were last tested on Mac Sonoma 14.1.2. + +Uninstalling DFHack +=================== + +Just renaming or removing the ``dfhooks`` library files is enough to disable +DFHack. If you would like to remove all DFHack files, consult the DFHack install +archive to see the list of files and remove the corresponding files in the Dwarf +Fortress folder. Any DFHack files left behind will not negatively affect DF. + +On Steam, uninstalling DFHack will cleanly remove everything that was installed +with DFHack, so there is nothing else for you to do. + +Note that Steam will leave behind the ``dfhack-config`` folder, which contains +all your personal DFHack-related settings and data. If you keep this folder, +all your settings will be restored when you reinstall DFHack later. + +Upgrading DFHack +================ + +Again, if you have installed from Steam, your copy of DFHack will automatically +be kept up to date. This section is for manual installers. + +First, remove the ``hack`` and ``stonesense`` folders in their entirety. This +ensures that files that don't exist in the latest version are properly removed +and don't affect your new installation. + +Then, follow the instructions in the `Installing DFHack`_ section above, making +sure to choose to overwrite any remaining top-level files when extracting. diff --git a/docs/Introduction.rst b/docs/Introduction.rst index 64b6b36a58..8f3506dad5 100644 --- a/docs/Introduction.rst +++ b/docs/Introduction.rst @@ -1,107 +1,111 @@ .. _introduction: ######################### -Introduction and Overview +Introduction and overview ######################### DFHack is a Dwarf Fortress memory access library, distributed with a wide variety of useful scripts and plugins. -The project is currently hosted at https://www.github.com/DFHack/dfhack, -and can be downloaded from `the releases page -`_. - -All new releases are announced in :forums:`the bay12 forums thread <139553>`, -which is also a good place for discussion and questions. - -For users, it provides a significant suite of bugfixes and interface -enhancements by default, and more can be enabled. There are also many tools -(such as `workflow` or `autodump`) which can make life easier. -You can even add third-party scripts and plugins to do almost anything! - -For modders, DFHack makes many things possible. Custom reactions, new -interactions, magic creature abilities, and more can be set through `modtools` -and custom raws. Non-standard DFHack scripts and inits can be stored in the -raw directory, making raws or saves fully self-contained for distribution - -or for coexistence in a single DF install, even with incompatible components. +The project is hosted `on GitHub `__, +and can be downloaded from `the releases page `__ +-- see `installing` for installation instructions. This is also where the +`DFHack bug tracker `__ is hosted. If you would like +to download the DFHack documentation for offline viewing, you can do so by clicking +the expansion panel in the lower right corner of our +`online documentation `__ and selecting your desired format from +the "Downloads" section. + +New releases are announced in the +`DF subreddit `__, the +`DFHack Discord `__, and the +`Bay12 forums thread `__. Discussion and questions are also +welcome in each of these venues. + +For users, DFHack provides a significant suite of bugfixes and interface +enhancements by default, and more features can be enabled as desired. There are +also many tools (such as `autofarm`) which automate aspects of gameplay many players +find toilsome. You can even add third-party scripts and plugins to do almost anything! + +For modders, DFHack makes many things possible. Custom reactions, new +interactions, magic creature abilities, and more can be set through `tools` +and custom raws. 3rd party DFHack scripts can be distributed `in mods ` +via the DF Steam Workshop or on the forums. For developers, DFHack unites the various ways tools access DF memory and -allows easier development of new tools. As an open-source project under -`various copyleft licences `, contributions are welcome. - - -.. contents:: - - -.. _installing: +allows easier development of new tools. As an open-source project under +`various open-source licenses `, contributions are welcome. -Installing DFHack -================= -DFHack is available for the SDL version of Dwarf Fortress on Windows, -any modern Linux distribution, and Mac OS X (10.6.8 and later). -It is possible to use Windows DF+DFHack under Wine on Linux or OS X. -Most releases only support the version of DF mentioned in their title - for -example, DFHack 0.40.24-r2 only supports DF 0.40.24 - but some releases -support earlier DF versions as well. Wherever possible, use the latest version -of DFHack built for the target version of DF. +.. contents:: Contents + :local: -Installing DFhack involves copying files from a release archive -into your DF folder, so that: -* On Windows, ``SDL.dll`` is replaced -* On Linux or OSX, the ``dfhack`` script is placed in the same folder as the ``df`` script - -Uninstalling is basically the same, in reverse: +Getting started +=============== -* On Windows, replace ``SDL.dll`` with ``SDLreal.dll``, then remove the DFHack files. -* On Linux or OSX, remove the DFHack files. +See `installing` for details about installing DFHack. -New players may wish to :wiki:`get a pack ` -with DFHack preinstalled. +Once DFHack is installed, it extends DF with a console that can be used to run +commands. The in-game version of this console is called `gui/launcher`, and you +can bring it up at any time by hitting the backtick (\`) key (on most keyboards +this is the same as the tilde (~) key). There are also external consoles you can +open in a separate window. On Windows, you can show this console with the `show` +command. On Linux and macOS, you will need to run the ``dfhack`` script from a +terminal, and that terminal will be used as the DFHack console. +Basic interaction with DFHack involves entering commands into the console. To +learn what commands are available, you can keep reading this documentation or +skip ahead and use the `ls` and `help` commands. The first command you should +run is likely `gui/control-panel` so you can set up which tools you would like +to enable now and which tools you want automatically started for new games. -Getting started -=============== -DFHack basically extends DF with something similar to the -console found in many PC games. +Another way to interact with DFHack is to set in-game `keybindings ` +to run commands in response to a hotkey. If you have specific commands that you +run frequently and that don't already have default keybindings, this can be a +better option than adding the command to the `gui/quickcmd` list. -If DFHack is installed correctly, it will automatically pop up a console -window once DF is started as usual on Windows. Linux and Mac OS X require -running the dfhack script from the terminal, and will use that terminal for -the console. +Commands can also run at startup via `init files `, or in batches +at other times with the `script` command. -* Basic interaction with dfhack involves entering commands into the console. - To learn what commands are available, you can keep reading this documentation - or skip ahead and use the `ls` and `help` commands. +Finally, some commands are persistent once enabled, and will sit in the +background managing or changing some aspect of the game if you `enable` them. -* Another way to interact with DFHack is to set in-game `keybindings ` - for certain commands. Many of the newer and user-friendly tools are designed - to be used this way. +.. note:: + In order to avoid user confusion, as a matter of policy all GUI tools + display the word :guilabel:`DFHack` on the screen somewhere while active. -* Commands can also run at startup via `init files `, - on in batches at other times with the `script` command. + When that is not appropriate because they merely add keybinding hints to + existing DF screens, they surround the added text or clickable buttons in red + square brackets. -* Finally, some commands are persistent once enabled, and will sit in the - background managing or changing some aspect of the game if you `enable` them. +For a more thorough introduction and guide through DFHack's capabilities, please see +the `quickstart`. +.. _support: -.. _troubleshooting: +Getting help +============ -Troubleshooting -=============== -Don't panic! Even if you need this section, it'll be OK :) +DFHack has several ways to get help online, including: -If something goes wrong, check the log files in DF's folder -(``stderr.log`` and ``stdout.log``). Looking at these might help you - -or someone else - solve the problem. Take screenshots of any weird -error messages, and take notes on what you did to cause them. +- The `DFHack Discord server `__ +- GitHub: + - for bugs, use the :issue:`issue tracker <>` + - for more open-ended questions, use the `discussion board + `__. Note that this is a + relatively-new feature as of 2021, but maintainers should still be + notified of any discussions here. +- The `DFHack thread on the Bay 12 Forum `__ +- The `/r/dwarffortress `__ questions thread on Reddit -If the search function in this documentation isn't enough and -:wiki:`the DF Wiki <>` hasn't helped, try asking in: +When reaching out to any support channels regarding problems with DFHack, please +remember to provide enough details for others to identify the issue. For +instance, specific error messages (copied text or screenshots) are helpful, as +well as any steps you can follow to reproduce the problem. Log output from +``stderr.log`` in the DF folder can often help point to the cause of issues. -- the `#dfhack IRC channel on freenode `_ -- the :forums:`Bay12 DFHack thread <139553>` -- the `/r/dwarffortress `_ questions thread -- the thread for the mod or Starter Pack you're using (if any) +Some common questions may also be answered in documentation, including: +- This documentation (`online here `__; search functionality available `here `) +- :wiki:`The DF wiki <>` diff --git a/docs/Lua API.rst b/docs/Lua API.rst deleted file mode 100644 index 2db98abad0..0000000000 --- a/docs/Lua API.rst +++ /dev/null @@ -1,3740 +0,0 @@ -.. _lua-api: - -############## -DFHack Lua API -############## - -DFHack has extensive support for -the Lua_ scripting language, providing access to: - -.. _Lua: http://www.lua.org - -1. Raw data structures used by the game. -2. Many C++ functions for high-level access to these - structures, and interaction with dfhack itself. -3. Some functions exported by C++ plugins. - -Lua code can be used both for writing scripts, which -are treated by DFHack command line prompt almost as -native C++ commands, and invoked by plugins written in C++. - -This document describes native API available to Lua in detail. -It does not describe all of the utility functions -implemented by Lua files located in :file:`hack/lua/*` -(:file:`library/lua/*` in the git repo). - - -.. contents:: - :depth: 3 - - -========================= -DF data structure wrapper -========================= - -.. contents:: - :local: - -Data structures of the game are defined in XML files located in :file:`library/xml` -(and `online `_, and automatically exported -to lua code as a tree of objects and functions under the ``df`` global, which -also broadly maps to the ``df`` namespace in the headers generated for C++. - -.. warning:: - The wrapper provides almost raw access to the memory - of the game, so mistakes in manipulating objects are as likely to - crash the game as equivalent plain C++ code would be. - - eg. NULL pointer access is safely detected, but dangling pointers aren't. - -Objects managed by the wrapper can be broadly classified into the following groups: - -1. Typed object pointers (references). - - References represent objects in DF memory with a known type. - - In addition to fields and methods defined by the wrapped type, - every reference has some built-in properties and methods. - -2. Untyped pointers - - Represented as lightuserdata. - - In assignment to a pointer NULL can be represented either as - ``nil``, or a NULL lightuserdata; reading a NULL pointer field - returns ``nil``. - -3. Named types - - Objects in the ``df`` tree that represent identity of struct, class, - enum and bitfield types. They host nested named types, static - methods, builtin properties & methods, and, for enums and bitfields, - the bi-directional mapping between key names and values. - -4. The ``global`` object - - ``df.global`` corresponds to the ``df::global`` namespace, and - behaves as a mix between a named type and a reference, containing - both nested types and fields corresponding to global symbols. - -In addition to the ``global`` object and top-level types the ``df`` -global also contains a few global builtin utility functions. - -Typed object references -======================= - -The underlying primitive lua object is userdata with a metatable. -Every structured field access produces a new userdata instance. - -All typed objects have the following built-in features: - -* ``ref1 == ref2``, ``tostring(ref)`` - - References implement equality by type & pointer value, and string conversion. - -* ``pairs(ref)`` - - Returns an iterator for the sequence of actual C++ field names - and values. Fields are enumerated in memory order. Methods and - lua wrapper properties are not included in the iteration. - - .. warning:: - a few of the data structures (like ui_look_list) - contain unions with pointers to different types with vtables. - Using pairs on such structs is an almost sure way to crash with - an access violation. - -* ``ref._kind`` - - Returns one of: ``primitive``, ``struct``, ``container``, - or ``bitfield``, as appropriate for the referenced object. - -* ``ref._type`` - - Returns the named type object or a string that represents - the referenced object type. - -* ``ref:sizeof()`` - - Returns *size, address* - -* ``ref:new()`` - - Allocates a new instance of the same type, and copies data - from the current object. - -* ``ref:delete()`` - - Destroys the object with the C++ ``delete`` operator. - If destructor is not available, returns *false*. - - .. warning:: - the lua reference object remains as a dangling - pointer, like a raw C++ pointer would. - -* ``ref:assign(object)`` - - Assigns data from object to ref. Object must either be another - ref of a compatible type, or a lua table; in the latter case - special recursive assignment rules are applied. - -* ``ref:_displace(index[,step])`` - - Returns a new reference with the pointer adjusted by index*step. - Step defaults to the natural object size. - -Primitive references --------------------- - -References of the *_kind* ``'primitive'`` are used for objects -that don't fit any of the other reference types. Such -references can only appear as a value of a pointer field, -or as a result of calling the ``_field()`` method. - -They behave as structs with one field ``value`` of the right type. - -To make working with numeric buffers easier, they also allow -numeric indices. Note that other than excluding negative values -no bound checking is performed, since buffer length is not available. -Index 0 is equivalent to the ``value`` field. - - -Struct references ------------------ - -Struct references are used for class and struct objects. - -They implement the following features: - -* ``ref.field``, ``ref.field = value`` - - Valid fields of the structure may be accessed by subscript. - - Primitive typed fields, i.e. numbers & strings, are converted - to/from matching lua values. The value of a pointer is a reference - to the target, or ``nil``/NULL. Complex types are represented by - a reference to the field within the structure; unless recursive - lua table assignment is used, such fields can only be read. - - .. note:: - In case of inheritance, *superclass* fields have precedence - over the subclass, but fields shadowed in this way can still - be accessed as ``ref['subclasstype.field']``. - - This shadowing order is necessary because vtable-based classes - are automatically exposed in their exact type, and the reverse - rule would make access to superclass fields unreliable. - -* ``ref._field(field)`` - - Returns a reference to a valid field. That is, unlike regular - subscript, it returns a reference to the field within the structure - even for primitive typed fields and pointers. - -* ``ref:vmethod(args...)`` - - Named virtual methods are also exposed, subject to the same - shadowing rules. - -* ``pairs(ref)`` - - Enumerates all real fields (but not methods) in memory - order, which is the same as declaration order. - -Container references --------------------- - -Containers represent vectors and arrays, possibly resizable. - -A container field can associate an enum to the container -reference, which allows accessing elements using string keys -instead of numerical indices. - -Note that two-dimensional arrays in C++ (ie pointers to pointers) -are exposed to lua as one-dimensional. The best way to handle this -is probably ``array[x].value:_displace(y)``. - -Implemented features: - -* ``ref._enum`` - - If the container has an associated enum, returns the matching - named type object. - -* ``#ref`` - - Returns the *length* of the container. - -* ``ref[index]`` - - Accesses the container element, using either a *0-based* numerical - index, or, if an enum is associated, a valid enum key string. - - Accessing an invalid index is an error, but some container types - may return a default value, or auto-resize instead for convenience. - Currently this relaxed mode is implemented by df-flagarray aka BitArray. - -* ``ref._field(index)`` - - Like with structs, returns a pointer to the array element, if possible. - Flag and bit arrays cannot return such pointer, so it fails with an error. - -* ``pairs(ref)``, ``ipairs(ref)`` - - If the container has no associated enum, both behave identically, - iterating over numerical indices in order. Otherwise, ipairs still - uses numbers, while pairs tries to substitute enum keys whenever - possible. - -* ``ref:resize(new_size)`` - - Resizes the container if supported, or fails with an error. - -* ``ref:insert(index,item)`` - - Inserts a new item at the specified index. To add at the end, - use ``#ref``, or just ``'#'`` as index. - -* ``ref:erase(index)`` - - Removes the element at the given valid index. - -Bitfield references -------------------- - -Bitfields behave like special fixed-size containers. -Consider them to be something in between structs and -fixed-size vectors. - -The ``_enum`` property points to the bitfield type. -Numerical indices correspond to the shift value, -and if a subfield occupies multiple bits, the -``ipairs`` order would have a gap. - -Since currently there is no API to allocate a bitfield -object fully in GC-managed lua heap, consider using the -lua table assignment feature outlined below in order to -pass bitfield values to dfhack API functions that need -them, e.g. ``matinfo:matches{metal=true}``. - - -Named types -=========== - -Named types are exposed in the ``df`` tree with names identical -to the C++ version, except for the ``::`` vs ``.`` difference. - -All types and the global object have the following features: - -* ``type._kind`` - - Evaluates to one of ``struct-type``, ``class-type``, ``enum-type``, - ``bitfield-type`` or ``global``. - -* ``type._identity`` - - Contains a lightuserdata pointing to the underlying - ``DFHack::type_instance`` object. - -Types excluding the global object also support: - -* ``type:sizeof()`` - - Returns the size of an object of the type. - -* ``type:new()`` - - Creates a new instance of an object of the type. - -* ``type:is_instance(object)`` - - Returns true if object is same or subclass type, or a reference - to an object of same or subclass type. It is permissible to pass - ``nil``, NULL or non-wrapper value as object; in this case the - method returns ``nil``. - -In addition to this, enum and bitfield types contain a -bi-directional mapping between key strings and values, and -also map ``_first_item`` and ``_last_item`` to the min and -max values. - -Struct and class types with instance-vector attribute in the -xml have a ``type.find(key)`` function that wraps the find -method provided in C++. - -Global functions -================ - -The ``df`` table itself contains the following functions and values: - -* ``NULL``, ``df.NULL`` - - Contains the NULL lightuserdata. - -* ``df.isnull(obj)`` - - Evaluates to true if obj is nil or NULL; false otherwise. - -* ``df.isvalid(obj[,allow_null])`` - - For supported objects returns one of ``type``, ``voidptr``, ``ref``. - - If *allow_null* is true, and obj is nil or NULL, returns ``null``. - - Otherwise returns *nil*. - -* ``df.sizeof(obj)`` - - For types and refs identical to ``obj:sizeof()``. - For lightuserdata returns *nil, address* - -* ``df.new(obj)``, ``df.delete(obj)``, ``df.assign(obj, obj2)`` - - Equivalent to using the matching methods of obj. - -* ``df._displace(obj,index[,step])`` - - For refs equivalent to the method, but also works with - lightuserdata (step is mandatory then). - -* ``df.is_instance(type,obj)`` - - Equivalent to the method, but also allows a reference as proxy for its type. - -* ``df.new(ptype[,count])`` - - Allocate a new instance, or an array of built-in types. - The ``ptype`` argument is a string from the following list: - ``string``, ``int8_t``, ``uint8_t``, ``int16_t``, ``uint16_t``, - ``int32_t``, ``uint32_t``, ``int64_t``, ``uint64_t``, ``bool``, - ``float``, ``double``. All of these except ``string`` can be - used with the count argument to allocate an array. - -* ``df.reinterpret_cast(type,ptr)`` - - Converts ptr to a ref of specified type. The type may be anything - acceptable to ``df.is_instance``. Ptr may be *nil*, a ref, - a lightuserdata, or a number. - - Returns *nil* if NULL, or a ref. - -.. _lua-api-table-assignment: - -Recursive table assignment -========================== - -Recursive assignment is invoked when a lua table is assigned -to a C++ object or field, i.e. one of: - -* ``ref:assign{...}`` -* ``ref.field = {...}`` - -The general mode of operation is that all fields of the table -are assigned to the fields of the target structure, roughly -emulating the following code:: - - function rec_assign(ref,table) - for key,value in pairs(table) do - ref[key] = value - end - end - -Since assigning a table to a field using = invokes the same -process, it is recursive. - -There are however some variations to this process depending -on the type of the field being assigned to: - -1. If the table contains an ``assign`` field, it is - applied first, using the ``ref:assign(value)`` method. - It is never assigned as a usual field. - -2. When a table is assigned to a non-NULL pointer field - using the ``ref.field = {...}`` syntax, it is applied - to the target of the pointer instead. - - If the pointer is NULL, the table is checked for a ``new`` field: - - a. If it is *nil* or *false*, assignment fails with an error. - - b. If it is *true*, the pointer is initialized with a newly - allocated object of the declared target type of the pointer. - - c. Otherwise, ``table.new`` must be a named type, or an - object of a type compatible with the pointer. The pointer - is initialized with the result of calling ``table.new:new()``. - - After this auto-vivification process, assignment proceeds - as if the pointer wasn't NULL. - - Obviously, the ``new`` field inside the table is always skipped - during the actual per-field assignment processing. - -3. If the target of the assignment is a container, a separate - rule set is used: - - a. If the table contains neither ``assign`` nor ``resize`` - fields, it is interpreted as an ordinary *1-based* lua - array. The container is resized to the #-size of the - table, and elements are assigned in numeric order:: - - ref:resize(#table); - for i=1,#table do ref[i-1] = table[i] end - - b. Otherwise, ``resize`` must be *true*, *false*, or - an explicit number. If it is not false, the container - is resized. After that the usual struct-like 'pairs' - assignment is performed. - - In case ``resize`` is *true*, the size is computed - by scanning the table for the largest numeric key. - - This means that in order to reassign only one element of - a container using this system, it is necessary to use:: - - { resize=false, [idx]=value } - -Since ``nil`` inside a table is indistinguishable from missing key, -it is necessary to use ``df.NULL`` as a null pointer value. - -This system is intended as a way to define a nested object -tree using pure lua data structures, and then materialize it in -C++ memory in one go. Note that if pointer auto-vivification -is used, an error in the middle of the recursive walk would -not destroy any objects allocated in this way, so the user -should be prepared to catch the error and do the necessary -cleanup. - -========== -DFHack API -========== - -.. contents:: - :local: - -DFHack utility functions are placed in the ``dfhack`` global tree. - -Native utilities -================ - -Input & Output --------------- - -* ``dfhack.print(args...)`` - - Output tab-separated args as standard lua print would do, - but without a newline. - -* ``print(args...)``, ``dfhack.println(args...)`` - - A replacement of the standard library print function that - works with DFHack output infrastructure. - -* ``dfhack.printerr(args...)`` - - Same as println; intended for errors. Uses red color and logs to stderr.log. - -* ``dfhack.color([color])`` - - Sets the current output color. If color is *nil* or *-1*, resets to default. - Returns the previous color value. - -* ``dfhack.is_interactive()`` - - Checks if the thread can access the interactive console and returns *true* or *false*. - -* ``dfhack.lineedit([prompt[,history_filename]])`` - - If the thread owns the interactive console, shows a prompt - and returns the entered string. Otherwise returns *nil, error*. - - Depending on the context, this function may actually yield the - running coroutine and let the C++ code release the core suspend - lock. Using an explicit ``dfhack.with_suspend`` will prevent - this, forcing the function to block on input with lock held. - -* ``dfhack.interpreter([prompt[,history_filename[,env]]])`` - - Starts an interactive lua interpreter, using the specified prompt - string, global environment and command-line history file. - - If the interactive console is not accessible, returns *nil, error*. - - -Exception handling ------------------- - -* ``dfhack.error(msg[,level[,verbose]])`` - - Throws a dfhack exception object with location and stack trace. - The verbose parameter controls whether the trace is printed by default. - -* ``qerror(msg[,level])`` - - Calls ``dfhack.error()`` with ``verbose`` being *false*. Intended to - be used for user-caused errors in scripts, where stack traces are not - desirable. - -* ``dfhack.pcall(f[,args...])`` - - Invokes f via xpcall, using an error function that attaches - a stack trace to the error. The same function is used by SafeCall - in C++, and dfhack.safecall. - -* ``safecall(f[,args...])``, ``dfhack.safecall(f[,args...])`` - - Just like pcall, but also prints the error using printerr before - returning. Intended as a convenience function. - -* ``dfhack.saferesume(coroutine[,args...])`` - - Compares to coroutine.resume like dfhack.safecall vs pcall. - -* ``dfhack.exception`` - - Metatable of error objects used by dfhack. The objects have the - following properties: - - ``err.where`` - The location prefix string, or *nil*. - ``err.message`` - The base message string. - ``err.stacktrace`` - The stack trace string, or *nil*. - ``err.cause`` - A different exception object, or *nil*. - ``err.thread`` - The coroutine that has thrown the exception. - ``err.verbose`` - Boolean, or *nil*; specifies if where and stacktrace should be printed. - ``tostring(err)``, or ``err:tostring([verbose])`` - Converts the exception to string. - -* ``dfhack.exception.verbose`` - - The default value of the ``verbose`` argument of ``err:tostring()``. - - -Miscellaneous -------------- - -* ``dfhack.VERSION`` - - DFHack version string constant. - -* ``dfhack.curry(func,args...)``, or ``curry(func,args...)`` - - Returns a closure that invokes the function with args combined - both from the curry call and the closure call itself. I.e. - ``curry(func,a,b)(c,d)`` equals ``func(a,b,c,d)``. - - -Locking and finalization ------------------------- - -* ``dfhack.with_suspend(f[,args...])`` - - Calls ``f`` with arguments after grabbing the DF core suspend lock. - Suspending is necessary for accessing a consistent state of DF memory. - - Returned values and errors are propagated through after releasing - the lock. It is safe to nest suspends. - - Every thread is allowed only one suspend per DF frame, so it is best - to group operations together in one big critical section. A plugin - can choose to run all lua code inside a C++-side suspend lock. - -* ``dfhack.call_with_finalizer(num_cleanup_args,always,cleanup_fn[,cleanup_args...],fn[,args...])`` - - Invokes ``fn`` with ``args``, and after it returns or throws an - error calls ``cleanup_fn`` with ``cleanup_args``. Any return values from - ``fn`` are propagated, and errors are re-thrown. - - The ``num_cleanup_args`` integer specifies the number of ``cleanup_args``, - and the ``always`` boolean specifies if cleanup should be called in any case, - or only in case of an error. - -* ``dfhack.with_finalize(cleanup_fn,fn[,args...])`` - - Calls ``fn`` with arguments, then finalizes with ``cleanup_fn``. - Implemented using ``call_with_finalizer(0,true,...)``. - -* ``dfhack.with_onerror(cleanup_fn,fn[,args...])`` - - Calls ``fn`` with arguments, then finalizes with ``cleanup_fn`` on any thrown error. - Implemented using ``call_with_finalizer(0,false,...)``. - -* ``dfhack.with_temp_object(obj,fn[,args...])`` - - Calls ``fn(obj,args...)``, then finalizes with ``obj:delete()``. - - -Persistent configuration storage --------------------------------- - -This api is intended for storing configuration options in the world itself. -It probably should be restricted to data that is world-dependent. - -Entries are identified by a string ``key``, but it is also possible to manage -multiple entries with the same key; their identity is determined by ``entry_id``. -Every entry has a mutable string ``value``, and an array of 7 mutable ``ints``. - -* ``dfhack.persistent.get(key)``, ``entry:get()`` - - Retrieves a persistent config record with the given string key, - or refreshes an already retrieved entry. If there are multiple - entries with the same key, it is undefined which one is retrieved - by the first version of the call. - - Returns entry, or *nil* if not found. - -* ``dfhack.persistent.delete(key)``, ``entry:delete()`` - - Removes an existing entry. Returns *true* if succeeded. - -* ``dfhack.persistent.get_all(key[,match_prefix])`` - - Retrieves all entries with the same key, or starting with key..'/'. - Calling ``get_all('',true)`` will match all entries. - - If none found, returns nil; otherwise returns an array of entries. - -* ``dfhack.persistent.save({key=str1, ...}[,new])``, ``entry:save([new])`` - - Saves changes in an entry, or creates a new one. Passing true as - new forces creation of a new entry even if one already exists; - otherwise the existing one is simply updated. - Returns *entry, did_create_new* - -Since the data is hidden in data structures owned by the DF world, -and automatically stored in the save game, these save and retrieval -functions can just copy values in memory without doing any actual I/O. -However, currently every entry has a 180+-byte dead-weight overhead. - -It is also possible to associate one bit per map tile with an entry, -using these two methods: - -* ``entry:getTilemask(block[, create])`` - - Retrieves the tile bitmask associated with this entry in the given map - block. If ``create`` is *true*, an empty mask is created if none exists; - otherwise the function returns *nil*, which must be assumed to be the same - as an all-zero mask. - -* ``entry:deleteTilemask(block)`` - - Deletes the associated tile mask from the given map block. - -Note that these masks are only saved in fortress mode, and also that deleting -the persistent entry will **NOT** delete the associated masks. - - -Material info lookup --------------------- - -A material info record has fields: - -* ``type``, ``index``, ``material`` - - DF material code pair, and a reference to the material object. - -* ``mode`` - - One of ``'builtin'``, ``'inorganic'``, ``'plant'``, ``'creature'``. - -* ``inorganic``, ``plant``, ``creature`` - - If the material is of the matching type, contains a reference to the raw object. - -* ``figure`` - - For a specific creature material contains a ref to the historical figure. - -Functions: - -* ``dfhack.matinfo.decode(type,index)`` - - Looks up material info for the given number pair; if not found, returs *nil*. - -* ``....decode(matinfo)``, ``....decode(item)``, ``....decode(obj)`` - - Uses ``matinfo.type``/``matinfo.index``, item getter vmethods, - or ``obj.mat_type``/``obj.mat_index`` to get the code pair. - -* ``dfhack.matinfo.find(token[,token...])`` - - Looks up material by a token string, or a pre-split string token sequence. - -* ``dfhack.matinfo.getToken(...)``, ``info:getToken()`` - - Applies ``decode`` and constructs a string token. - -* ``info:toString([temperature[,named]])`` - - Returns the human-readable name at the given temperature. - -* ``info:getCraftClass()`` - - Returns the classification used for craft skills. - -* ``info:matches(obj)`` - - Checks if the material matches job_material_category or job_item. - Accept dfhack_material_category auto-assign table. - -.. _lua_api_random: - -Random number generation ------------------------- - -* ``dfhack.random.new([seed[,perturb_count]])`` - - Creates a new random number generator object. Without any - arguments, the object is initialized using current time. - Otherwise, the seed must be either a non-negative integer, - or a list of such integers. The second argument may specify - the number of additional randomization steps performed to - improve the initial state. - -* ``rng:init([seed[,perturb_count]])`` - - Re-initializes an already existing random number generator object. - -* ``rng:random([limit])`` - - Returns a random integer. If ``limit`` is specified, the value - is in the range [0, limit); otherwise it uses the whole 32-bit - unsigned integer range. - -* ``rng:drandom()`` - - Returns a random floating-point number in the range [0,1). - -* ``rng:drandom0()`` - - Returns a random floating-point number in the range (0,1). - -* ``rng:drandom1()`` - - Returns a random floating-point number in the range [0,1]. - -* ``rng:unitrandom()`` - - Returns a random floating-point number in the range [-1,1]. - -* ``rng:unitvector([size])`` - - Returns multiple values that form a random vector of length 1, - uniformly distributed over the corresponding sphere surface. - The default size is 3. - -* ``fn = rng:perlin([dim]); fn(x[,y[,z]])`` - - Returns a closure that computes a classical Perlin noise function - of dimension *dim*, initialized from this random generator. - Dimension may be 1, 2 or 3 (default). - - -C++ function wrappers -===================== - -Thin wrappers around C++ functions, similar to the ones for virtual methods. -One notable difference is that these explicit wrappers allow argument count -adjustment according to the usual lua rules, so trailing false/nil arguments -can be omitted. - -* ``dfhack.getOSType()`` - - Returns the OS type string from ``symbols.xml``. - -* ``dfhack.getDFVersion()`` - - Returns the DF version string from ``symbols.xml``. - -* ``dfhack.getDFHackVersion()`` -* ``dfhack.getDFHackRelease()`` -* ``dfhack.getCompiledDFVersion()`` -* ``dfhack.getGitDescription()`` -* ``dfhack.getGitCommit()`` -* ``dfhack.isRelease()`` - - Return information about the DFHack build in use. - - .. note:: - ``getCompiledDFVersion()`` returns the DF version specified at compile time, - while ``getDFVersion()`` returns the version and typically the OS as well. - These do not necessarily match - for example, DFHack 0.34.11-r5 worked with - DF 0.34.10 and 0.34.11, so the former function would always return ``0.34.11`` - while the latter would return ``v0.34.10 `` or ``v0.34.11 ``. - -* ``dfhack.getDFPath()`` - - Returns the DF directory path. - -* ``dfhack.getHackPath()`` - - Returns the dfhack directory path, i.e. ``".../df/hack/"``. - -* ``dfhack.getSavePath()`` - - Returns the path to the current save directory, or *nil* if no save loaded. - -* ``dfhack.getTickCount()`` - - Returns the tick count in ms, exactly as DF ui uses. - -* ``dfhack.isWorldLoaded()`` - - Checks if the world is loaded. - -* ``dfhack.isMapLoaded()`` - - Checks if the world and map are loaded. - -* ``dfhack.TranslateName(name[,in_english,only_last_name])`` - - Convert a language_name or only the last name part to string. - -* ``dfhack.df2utf(string)`` - - Convert a string from DF's CP437 encoding to UTF-8. - -* ``dfhack.df2console()`` - - Convert a string from DF's CP437 encoding to the correct encoding for the - DFHack console. - -* ``dfhack.utf2df(string)`` - - Convert a string from UTF-8 to DF's CP437 encoding. - -**Note:** When printing CP437-encoded text to the console (for example, names -returned from TranslateName()), use ``print(dfhack.df2console(text)`` to ensure -proper display on all platforms. - - -Gui module ----------- - -* ``dfhack.gui.getCurViewscreen([skip_dismissed])`` - - Returns the topmost viewscreen. If ``skip_dismissed`` is *true*, - ignores screens already marked to be removed. - -* ``dfhack.gui.getFocusString(viewscreen)`` - - Returns a string representation of the current focus position - in the ui. The string has a "screen/foo/bar/baz..." format. - -* ``dfhack.gui.getCurFocus([skip_dismissed])`` - - Returns the focus string of the current viewscreen. - -* ``dfhack.gui.getViewscreenByType(type [, depth])`` - - Returns the topmost viewscreen out of the top ``depth`` viewscreens with - the specified type (e.g. ``df.viewscreen_titlest``), or ``nil`` if none match. - If ``depth`` is not specified or is less than 1, all viewscreens are checked. - -* ``dfhack.gui.getSelectedWorkshopJob([silent])`` - - When a job is selected in :kbd:`q` mode, returns the job, else - prints error unless silent and returns *nil*. - -* ``dfhack.gui.getSelectedJob([silent])`` - - Returns the job selected in a workshop or unit/jobs screen. - -* ``dfhack.gui.getSelectedUnit([silent])`` - - Returns the unit selected via :kbd:`v`, :kbd:`k`, unit/jobs, or - a full-screen item view of a cage or suchlike. - -* ``dfhack.gui.getSelectedItem([silent])`` - - Returns the item selected via :kbd:`v` ->inventory, :kbd:`k`, :kbd:`t`, or - a full-screen item view of a container. Note that in the - last case, the highlighted *contained item* is returned, not - the container itself. - -* ``dfhack.gui.getSelectedBuilding([silent])`` - - Returns the building selected via :kbd:`q`, :kbd:`t`, :kbd:`k` or :kbd:`i`. - -* ``dfhack.gui.writeToGamelog(text)`` - - Writes a string to :file:`gamelog.txt` without doing an announcement. - -* ``dfhack.gui.makeAnnouncement(type,flags,pos,text,color[,is_bright])`` - - Adds an announcement with given announcement_type, text, color, and brightness. - The is_bright boolean actually seems to invert the brightness. - - The announcement is written to :file:`gamelog.txt`. The announcement_flags - argument provides a custom set of :file:`announcements.txt` options, - which specify if the message should actually be displayed in the - announcement list, and whether to recenter or show a popup. - - Returns the index of the new announcement in ``df.global.world.status.reports``, or -1. - -* ``dfhack.gui.addCombatReport(unit,slot,report_index)`` - - Adds the report with the given index (returned by makeAnnouncement) - to the specified group of the given unit. Returns *true* on success. - -* ``dfhack.gui.addCombatReportAuto(unit,flags,report_index)`` - - Adds the report with the given index to the appropriate group(s) - of the given unit, as requested by the flags. - -* ``dfhack.gui.showAnnouncement(text,color[,is_bright])`` - - Adds a regular announcement with given text, color, and brightness. - The is_bright boolean actually seems to invert the brightness. - -* ``dfhack.gui.showZoomAnnouncement(type,pos,text,color[,is_bright])`` - - Like above, but also specifies a position you can zoom to from the announcement menu. - -* ``dfhack.gui.showPopupAnnouncement(text,color[,is_bright])`` - - Pops up a titan-style modal announcement window. - -* ``dfhack.gui.showAutoAnnouncement(type,pos,text,color[,is_bright,unit1,unit2])`` - - Uses the type to look up options from announcements.txt, and calls the above - operations accordingly. The units are used to call ``addCombatReportAuto``. - - -Job module ----------- - -* ``dfhack.job.cloneJobStruct(job)`` - - Creates a deep copy of the given job. - -* ``dfhack.job.printJobDetails(job)`` - - Prints info about the job. - -* ``dfhack.job.printItemDetails(jobitem,idx)`` - - Prints info about the job item. - -* ``dfhack.job.getGeneralRef(job, type)`` - - Searches for a general_ref with the given type. - -* ``dfhack.job.getSpecificRef(job, type)`` - - Searches for a specific_ref with the given type. - -* ``dfhack.job.getHolder(job)`` - - Returns the building holding the job. - -* ``dfhack.job.getWorker(job)`` - - Returns the unit performing the job. - -* ``dfhack.job.setJobCooldown(building,worker,timeout)`` - - Prevent the worker from taking jobs at the specified workshop for the specified time. - This doesn't decrease the timeout in any circumstances. - -* ``dfhack.job.removeWorker(job,timeout)`` - - Removes the worker from the specified workshop job, and sets the cooldown. - Returns *true* on success. - -* ``dfhack.job.checkBuildingsNow()`` - - Instructs the game to check buildings for jobs next frame and assign workers. - -* ``dfhack.job.checkDesignationsNow()`` - - Instructs the game to check designations for jobs next frame and assign workers. - -* ``dfhack.job.is_equal(job1,job2)`` - - Compares important fields in the job and nested item structures. - -* ``dfhack.job.is_item_equal(job_item1,job_item2)`` - - Compares important fields in the job item structures. - -* ``dfhack.job.linkIntoWorld(job,new_id)`` - - Adds job into ``df.global.job_list``, and if new_id - is true, then also sets its id and increases - ``df.global.job_next_id`` - -* ``dfhack.job.listNewlyCreated(first_id)`` - - Returns the current value of ``df.global.job_next_id``, and - if there are any jobs with ``first_id <= id < job_next_id``, - a lua list containing them. - -* ``dfhack.job.isSuitableItem(job_item, item_type, item_subtype)`` - - Does basic sanity checks to verify if the suggested item type matches - the flags in the job item. - -* ``dfhack.job.isSuitableMaterial(job_item, mat_type, mat_index)`` - - Likewise, if replacing material. - -* ``dfhack.job.getName(job)`` - - Returns the job's description, as seen in the Units and Jobs screens. - -Units module ------------- - -* ``dfhack.units.getPosition(unit)`` - - Returns true *x,y,z* of the unit, or *nil* if invalid; may be not equal to unit.pos if caged. - -* ``dfhack.units.getGeneralRef(unit, type)`` - - Searches for a general_ref with the given type. - -* ``dfhack.units.getSpecificRef(unit, type)`` - - Searches for a specific_ref with the given type. - -* ``dfhack.units.getContainer(unit)`` - - Returns the container (cage) item or *nil*. - -* ``dfhack.units.setNickname(unit,nick)`` - - Sets the unit's nickname properly. - -* ``dfhack.units.getVisibleName(unit)`` - - Returns the language_name object visible in game, accounting for false identities. - -* ``dfhack.units.getIdentity(unit)`` - - Returns the false identity of the unit if it has one, or *nil*. - -* ``dfhack.units.getNemesis(unit)`` - - Returns the nemesis record of the unit if it has one, or *nil*. - -* ``dfhack.units.isHidingCurse(unit)`` - - Checks if the unit hides improved attributes from its curse. - -* ``dfhack.units.getPhysicalAttrValue(unit, attr_type)`` -* ``dfhack.units.getMentalAttrValue(unit, attr_type)`` - - Computes the effective attribute value, including curse effect. - -* ``dfhack.units.isCrazed(unit)`` -* ``dfhack.units.isOpposedToLife(unit)`` -* ``dfhack.units.hasExtravision(unit)`` -* ``dfhack.units.isBloodsucker(unit)`` - - Simple checks of caste attributes that can be modified by curses. - -* ``dfhack.units.getMiscTrait(unit, type[, create])`` - - Finds (or creates if requested) a misc trait object with the given id. - -* ``dfhack.units.isDead(unit)`` - - The unit is completely dead and passive, or a ghost. - -* ``dfhack.units.isAlive(unit)`` - - The unit isn't dead or undead. - -* ``dfhack.units.isSane(unit)`` - - The unit is capable of rational action, i.e. not dead, insane, zombie, or active werewolf. - -* ``dfhack.units.isDwarf(unit)`` - - The unit is of the correct race of the fortress. - -* ``dfhack.units.isCitizen(unit)`` - - The unit is an alive sane citizen of the fortress; wraps the - same checks the game uses to decide game-over by extinction. - -* ``dfhack.units.getAge(unit[,true_age])`` - - Returns the age of the unit in years as a floating-point value. - If ``true_age`` is true, ignores false identities. - -* ``dfhack.units.getNominalSkill(unit, skill[, use_rust])`` - - Retrieves the nominal skill level for the given unit. If ``use_rust`` - is *true*, subtracts the rust penalty. - -* ``dfhack.units.getEffectiveSkill(unit, skill)`` - - Computes the effective rating for the given skill, taking into account exhaustion, pain etc. - -* ``dfhack.units.getExperience(unit, skill[, total])`` - - Returns the experience value for the given skill. If ``total`` is true, adds experience implied by the current rating. - -* ``dfhack.units.computeMovementSpeed(unit)`` - - Computes number of frames * 100 it takes the unit to move in its current state of mind and body. - -* ``dfhack.units.computeSlowdownFactor(unit)`` - - Meandering and floundering in liquid introduces additional slowdown. It is - random, but the function computes and returns the expected mean factor as a float. - -* ``dfhack.units.getNoblePositions(unit)`` - - Returns a list of tables describing noble position assignments, or *nil*. - Every table has fields ``entity``, ``assignment`` and ``position``. - -* ``dfhack.units.getProfessionName(unit[,ignore_noble,plural])`` - - Retrieves the profession name using custom profession, noble assignments - or raws. The ``ignore_noble`` boolean disables the use of noble positions. - -* ``dfhack.units.getCasteProfessionName(race,caste,prof_id[,plural])`` - - Retrieves the profession name for the given race/caste using raws. - -* ``dfhack.units.getProfessionColor(unit[,ignore_noble])`` - - Retrieves the color associated with the profession, using noble assignments - or raws. The ``ignore_noble`` boolean disables the use of noble positions. - -* ``dfhack.units.getCasteProfessionColor(race,caste,prof_id)`` - - Retrieves the profession color for the given race/caste using raws. - - -Items module ------------- - -* ``dfhack.items.getPosition(item)`` - - Returns true *x,y,z* of the item, or *nil* if invalid; may be not equal to item.pos if in inventory. - -* ``dfhack.items.getDescription(item, type[, decorate])`` - - Returns the string description of the item, as produced by the ``getItemDescription`` - method. If decorate is true, also adds markings for quality and improvements. - -* ``dfhack.items.getGeneralRef(item, type)`` - - Searches for a general_ref with the given type. - -* ``dfhack.items.getSpecificRef(item, type)`` - - Searches for a specific_ref with the given type. - -* ``dfhack.items.getOwner(item)`` - - Returns the owner unit or *nil*. - -* ``dfhack.items.setOwner(item,unit)`` - - Replaces the owner of the item. If unit is *nil*, removes ownership. - Returns *false* in case of error. - -* ``dfhack.items.getContainer(item)`` - - Returns the container item or *nil*. - -* ``dfhack.items.getContainedItems(item)`` - - Returns a list of items contained in this one. - -* ``dfhack.items.getHolderBuilding(item)`` - - Returns the holder building or *nil*. - -* ``dfhack.items.getHolderUnit(item)`` - - Returns the holder unit or *nil*. - -* ``dfhack.items.moveToGround(item,pos)`` - - Move the item to the ground at position. Returns *false* if impossible. - -* ``dfhack.items.moveToContainer(item,container)`` - - Move the item to the container. Returns *false* if impossible. - -* ``dfhack.items.moveToBuilding(item,building[,use_mode[,force_in_building])`` - - Move the item to the building. Returns *false* if impossible. - - ``use_mode`` defaults to 0. If set to 2, the item will be treated as part of the building. - - If ``force_in_building`` is true, the item will be considered to be stored by the building - (used for items temporarily used in traps in vanilla DF) - -* ``dfhack.items.moveToInventory(item,unit,use_mode,body_part)`` - - Move the item to the unit inventory. Returns *false* if impossible. - -* ``dfhack.items.remove(item[, no_uncat])`` - - Removes the item, and marks it for garbage collection unless ``no_uncat`` is true. - -* ``dfhack.items.makeProjectile(item)`` - - Turns the item into a projectile, and returns the new object, or *nil* if impossible. - -* ``dfhack.items.isCasteMaterial(item_type)`` - - Returns *true* if this item type uses a creature/caste pair as its material. - -* ``dfhack.items.getSubtypeCount(item_type)`` - - Returns the number of raw-defined subtypes of the given item type, or *-1* if not applicable. - -* ``dfhack.items.getSubtypeDef(item_type, subtype)`` - - Returns the raw definition for the given item type and subtype, or *nil* if invalid. - -* ``dfhack.items.getItemBaseValue(item_type, subtype, material, mat_index)`` - - Calculates the base value for an item of the specified type and material. - -* ``dfhack.items.getValue(item)`` - - Calculates the Basic Value of an item, as seen in the View Item screen. - - -Maps module ------------ - -* ``dfhack.maps.getSize()`` - - Returns map size in blocks: *x, y, z* - -* ``dfhack.maps.getTileSize()`` - - Returns map size in tiles: *x, y, z* - -* ``dfhack.maps.getBlock(x,y,z)`` - - Returns a map block object for given x,y,z in local block coordinates. - -* ``dfhack.maps.isValidTilePos(coords)``, or ``isValidTilePos(x,y,z)`` - - Checks if the given df::coord or x,y,z in local tile coordinates are valid. - -* ``dfhack.maps.getTileBlock(coords)``, or ``getTileBlock(x,y,z)`` - - Returns a map block object for given df::coord or x,y,z in local tile coordinates. - -* ``dfhack.maps.ensureTileBlock(coords)``, or ``ensureTileBlock(x,y,z)`` - - Like ``getTileBlock``, but if the block is not allocated, try creating it. - -* ``dfhack.maps.getTileType(coords)``, or ``getTileType(x,y,z)`` - - Returns the tile type at the given coordinates, or *nil* if invalid. - -* ``dfhack.maps.getTileFlags(coords)``, or ``getTileFlags(x,y,z)`` - - Returns designation and occupancy references for the given coordinates, or *nil, nil* if invalid. - -* ``dfhack.maps.getRegionBiome(region_coord2d)``, or ``getRegionBiome(x,y)`` - - Returns the biome info struct for the given global map region. - -* ``dfhack.maps.enableBlockUpdates(block[,flow,temperature])`` - - Enables updates for liquid flow or temperature, unless already active. - -* ``dfhack.maps.spawnFlow(pos,type,mat_type,mat_index,dimension)`` - - Spawns a new flow (i.e. steam/mist/dust/etc) at the given pos, and with - the given parameters. Returns it, or *nil* if unsuccessful. - -* ``dfhack.maps.getGlobalInitFeature(index)`` - - Returns the global feature object with the given index. - -* ``dfhack.maps.getLocalInitFeature(region_coord2d,index)`` - - Returns the local feature object with the given region coords and index. - -* ``dfhack.maps.getTileBiomeRgn(coords)``, or ``getTileBiomeRgn(x,y,z)`` - - Returns *x, y* for use with ``getRegionBiome``. - -* ``dfhack.maps.canWalkBetween(pos1, pos2)`` - - Checks if a dwarf may be able to walk between the two tiles, - using a pathfinding cache maintained by the game. - - .. note:: - This cache is only updated when the game is unpaused, and thus - can get out of date if doors are forbidden or unforbidden, or - tools like `liquids` or `tiletypes` are used. It also cannot possibly - take into account anything that depends on the actual units, like - burrows, or the presence of invaders. - -* ``dfhack.maps.hasTileAssignment(tilemask)`` - - Checks if the tile_bitmask object is not *nil* and contains any set bits; returns *true* or *false*. - -* ``dfhack.maps.getTileAssignment(tilemask,x,y)`` - - Checks if the tile_bitmask object is not *nil* and has the relevant bit set; returns *true* or *false*. - -* ``dfhack.maps.setTileAssignment(tilemask,x,y,enable)`` - - Sets the relevant bit in the tile_bitmask object to the *enable* argument. - -* ``dfhack.maps.resetTileAssignment(tilemask[,enable])`` - - Sets all bits in the mask to the *enable* argument. - - -Burrows module --------------- - -* ``dfhack.burrows.findByName(name)`` - - Returns the burrow pointer or *nil*. - -* ``dfhack.burrows.clearUnits(burrow)`` - - Removes all units from the burrow. - -* ``dfhack.burrows.isAssignedUnit(burrow,unit)`` - - Checks if the unit is in the burrow. - -* ``dfhack.burrows.setAssignedUnit(burrow,unit,enable)`` - - Adds or removes the unit from the burrow. - -* ``dfhack.burrows.clearTiles(burrow)`` - - Removes all tiles from the burrow. - -* ``dfhack.burrows.listBlocks(burrow)`` - - Returns a table of map block pointers. - -* ``dfhack.burrows.isAssignedTile(burrow,tile_coord)`` - - Checks if the tile is in burrow. - -* ``dfhack.burrows.setAssignedTile(burrow,tile_coord,enable)`` - - Adds or removes the tile from the burrow. Returns *false* if invalid coords. - -* ``dfhack.burrows.isAssignedBlockTile(burrow,block,x,y)`` - - Checks if the tile within the block is in burrow. - -* ``dfhack.burrows.setAssignedBlockTile(burrow,block,x,y,enable)`` - - Adds or removes the tile from the burrow. Returns *false* if invalid coords. - - -Buildings module ----------------- - -General -~~~~~~~ - -* ``dfhack.buildings.getGeneralRef(building, type)`` - - Searches for a general_ref with the given type. - -* ``dfhack.buildings.getSpecificRef(building, type)`` - - Searches for a specific_ref with the given type. - -* ``dfhack.buildings.setOwner(item,unit)`` - - Replaces the owner of the building. If unit is *nil*, removes ownership. - Returns *false* in case of error. - -* ``dfhack.buildings.getSize(building)`` - - Returns *width, height, centerx, centery*. - -* ``dfhack.buildings.findAtTile(pos)``, or ``findAtTile(x,y,z)`` - - Scans the buildings for the one located at the given tile. - Does not work on civzones. Warning: linear scan if the map - tile indicates there are buildings at it. - -* ``dfhack.buildings.findCivzonesAt(pos)``, or ``findCivzonesAt(x,y,z)`` - - Scans civzones, and returns a lua sequence of those that touch - the given tile, or *nil* if none. - -* ``dfhack.buildings.getCorrectSize(width, height, type, subtype, custom, direction)`` - - Computes correct dimensions for the specified building type and orientation, - using width and height for flexible dimensions. - Returns *is_flexible, width, height, center_x, center_y*. - -* ``dfhack.buildings.checkFreeTiles(pos,size[,extents,change_extents,allow_occupied])`` - - Checks if the rectangle defined by ``pos`` and ``size``, and possibly extents, - can be used for placing a building. If ``change_extents`` is true, bad tiles - are removed from extents. If ``allow_occupied``, the occupancy test is skipped. - -* ``dfhack.buildings.countExtentTiles(extents,defval)`` - - Returns the number of tiles included by extents, or defval. - -* ``dfhack.buildings.containsTile(building, x, y[, room])`` - - Checks if the building contains the specified tile, either directly, or as room. - -* ``dfhack.buildings.hasSupport(pos,size)`` - - Checks if a bridge constructed at specified position would have - support from terrain, and thus won't collapse if retracted. - -* ``dfhack.buildings.getStockpileContents(stockpile)`` - - Returns a list of items stored on the given stockpile. - Ignores empty bins, barrels, and wheelbarrows assigned as storage and transport for that stockpile. - -Low-level -~~~~~~~~~ -Low-level building creation functions: - -* ``dfhack.buildings.allocInstance(pos, type, subtype, custom)`` - - Creates a new building instance of given type, subtype and custom type, - at specified position. Returns the object, or *nil* in case of an error. - -* ``dfhack.buildings.setSize(building, width, height, direction)`` - - Configures an object returned by ``allocInstance``, using specified - parameters wherever appropriate. If the building has fixed size along - any dimension, the corresponding input parameter will be ignored. - Returns *false* if the building cannot be placed, or *true, width, - height, rect_area, true_area*. Returned width and height are the - final values used by the building; true_area is less than rect_area - if any tiles were removed from designation. - -* ``dfhack.buildings.constructAbstract(building)`` - - Links a fully configured object created by ``allocInstance`` into the - world. The object must be an abstract building, i.e. a stockpile or civzone. - Returns *true*, or *false* if impossible. - -* ``dfhack.buildings.constructWithItems(building, items)`` - - Links a fully configured object created by ``allocInstance`` into the - world for construction, using a list of specific items as material. - Returns *true*, or *false* if impossible. - -* ``dfhack.buildings.constructWithFilters(building, job_items)`` - - Links a fully configured object created by ``allocInstance`` into the - world for construction, using a list of job_item filters as inputs. - Returns *true*, or *false* if impossible. Filter objects are claimed - and possibly destroyed in any case. - Use a negative ``quantity`` field value to auto-compute the amount - from the size of the building. - -* ``dfhack.buildings.deconstruct(building)`` - - Destroys the building, or queues a deconstruction job. - Returns *true* if the building was destroyed and deallocated immediately. - -High-level -~~~~~~~~~~ -More high-level functions are implemented in lua and can be loaded by -``require('dfhack.buildings')``. See ``hack/lua/dfhack/buildings.lua``. - -Among them are: - -* ``dfhack.buildings.getFiltersByType(argtable,type,subtype,custom)`` - - Returns a sequence of lua structures, describing input item filters - suitable for the specified building type, or *nil* if unknown or invalid. - The returned sequence is suitable for use as the ``job_items`` argument - of ``constructWithFilters``. - Uses tables defined in ``buildings.lua``. - - Argtable members ``material`` (the default name), ``bucket``, ``barrel``, - ``chain``, ``mechanism``, ``screw``, ``pipe``, ``anvil``, ``weapon`` are used to - augment the basic attributes with more detailed information if the - building has input items with the matching name (see the tables for naming details). - Note that it is impossible to *override* any properties this way, only supply those that - are not mentioned otherwise; one exception is that flags2.non_economic - is automatically cleared if an explicit material is specified. - -* ``dfhack.buildings.constructBuilding{...}`` - - Creates a building in one call, using options contained - in the argument table. Returns the building, or *nil, error*. - - .. note:: - Despite the name, unless the building is abstract, - the function creates it in an 'unconstructed' stage, with - a queued in-game job that will actually construct it. I.e. - the function replicates programmatically what can be done - through the construct building menu in the game ui, except - that it does less environment constraint checking. - - The following options can be used: - - - ``pos = coordinates``, or ``x = ..., y = ..., z = ...`` - - Mandatory. Specifies the left upper corner of the building. - - - ``type = df.building_type.FOO, subtype = ..., custom = ...`` - - Mandatory. Specifies the type of the building. Obviously, subtype - and custom are only expected if the type requires them. - - - ``fields = { ... }`` - - Initializes fields of the building object after creation with ``df.assign``. - - - ``width = ..., height = ..., direction = ...`` - - Sets size and orientation of the building. If it is - fixed-size, specified dimensions are ignored. - - - ``full_rectangle = true`` - - For buildings like stockpiles or farm plots that can normally - accomodate individual tile exclusion, forces an error if any - tiles within the specified width*height are obstructed. - - - ``items = { item, item ... }``, or ``filters = { {...}, {...}... }`` - - Specifies explicit items or item filters to use in construction. - It is the job of the user to ensure they are correct for the building type. - - - ``abstract = true`` - - Specifies that the building is abstract and does not require construction. - Required for stockpiles and civzones; an error otherwise. - - - ``material = {...}, mechanism = {...}, ...`` - - If none of ``items``, ``filter``, or ``abstract`` is used, - the function uses ``getFiltersByType`` to compute the input - item filters, and passes the argument table through. If no filters - can be determined this way, ``constructBuilding`` throws an error. - - -Constructions module --------------------- - -* ``dfhack.constructions.designateNew(pos,type,item_type,mat_index)`` - - Designates a new construction at given position. If there already is - a planned but not completed construction there, changes its type. - Returns *true*, or *false* if obstructed. - Note that designated constructions are technically buildings. - -* ``dfhack.constructions.designateRemove(pos)``, or ``designateRemove(x,y,z)`` - - If there is a construction or a planned construction at the specified - coordinates, designates it for removal, or instantly cancels the planned one. - Returns *true, was_only_planned* if removed; or *false* if none found. - - -Screen API ----------- - -The screen module implements support for drawing to the tiled screen of the game. -Note that drawing only has any effect when done from callbacks, so it can only -be feasibly used in the core context. - -Basic painting functions: - -* ``dfhack.screen.getWindowSize()`` - - Returns *width, height* of the screen. - -* ``dfhack.screen.getMousePos()`` - - Returns *x,y* of the tile the mouse is over. - -* ``dfhack.screen.inGraphicsMode()`` - - Checks if [GRAPHICS:YES] was specified in init. - -* ``dfhack.screen.paintTile(pen,x,y[,char,tile])`` - - Paints a tile using given parameters. See below for a description of pen. - - Returns *false* if coordinates out of bounds, or other error. - -* ``dfhack.screen.readTile(x,y)`` - - Retrieves the contents of the specified tile from the screen buffers. - Returns a pen object, or *nil* if invalid or TrueType. - -* ``dfhack.screen.paintString(pen,x,y,text)`` - - Paints the string starting at *x,y*. Uses the string characters - in sequence to override the ``ch`` field of pen. - - Returns *true* if painting at least one character succeeded. - -* ``dfhack.screen.fillRect(pen,x1,y1,x2,y2)`` - - Fills the rectangle specified by the coordinates with the given pen. - Returns *true* if painting at least one character succeeded. - -* ``dfhack.screen.findGraphicsTile(pagename,x,y)`` - - Finds a tile from a graphics set (i.e. the raws used for creatures), - if in graphics mode and loaded. - - Returns: *tile, tile_grayscale*, or *nil* if not found. - The values can then be used for the *tile* field of *pen* structures. - -* ``dfhack.screen.clear()`` - - Fills the screen with blank background. - -* ``dfhack.screen.invalidate()`` - - Requests repaint of the screen by setting a flag. Unlike other - functions in this section, this may be used at any time. - -* ``dfhack.screen.getKeyDisplay(key)`` - - Returns the string that should be used to represent the given - logical keybinding on the screen in texts like "press Key to ...". - -* ``dfhack.screen.keyToChar(key)`` - - Returns the integer character code of the string input - character represented by the given logical keybinding, - or *nil* if not a string input key. - -* ``dfhack.screen.charToKey(charcode)`` - - Returns the keybinding representing the given string input - character, or *nil* if impossible. - -The "pen" argument used by functions above may be represented by -a table with the following possible fields: - - ``ch`` - Provides the ordinary tile character, as either a 1-character string or a number. - Can be overridden with the ``char`` function parameter. - ``fg`` - Foreground color for the ordinary tile. Defaults to COLOR_GREY (7). - ``bg`` - Background color for the ordinary tile. Defaults to COLOR_BLACK (0). - ``bold`` - Bright/bold text flag. If *nil*, computed based on (fg & 8); fg is masked to 3 bits. - Otherwise should be *true/false*. - ``tile`` - Graphical tile id. Ignored unless [GRAPHICS:YES] was in init.txt. - ``tile_color = true`` - Specifies that the tile should be shaded with *fg/bg*. - ``tile_fg, tile_bg`` - If specified, overrides *tile_color* and supplies shading colors directly. - -Alternatively, it may be a pre-parsed native object with the following API: - -* ``dfhack.pen.make(base[,pen_or_fg,bg,bold])`` - - Creates a new pre-parsed pen by combining its arguments according to the - following rules: - - 1. The ``base`` argument may be a pen object, a pen table as specified above, - or a single color value. In the single value case, it is split into - ``fg`` and ``bold`` properties, and others are initialized to 0. - This argument will be converted to a pre-parsed object and returned - if there are no other arguments. - - 2. If the ``pen_or_fg`` argument is specified as a table or object, it - completely replaces the base, and is returned instead of it. - - 3. Otherwise, the non-nil subset of the optional arguments is used - to update the ``fg``, ``bg`` and ``bold`` properties of the base. - If the ``bold`` flag is *nil*, but *pen_or_fg* is a number, ``bold`` - is deduced from it like in the simple base case. - - This function always returns a new pre-parsed pen, or *nil*. - -* ``dfhack.pen.parse(base[,pen_or_fg,bg,bold])`` - - Exactly like the above function, but returns ``base`` or ``pen_or_fg`` - directly if they are already a pre-parsed native object. - -* ``pen.property``, ``pen.property = value``, ``pairs(pen)`` - - Pre-parsed pens support reading and setting their properties, - but don't behave exactly like a simple table would; for instance, - assigning to ``pen.tile_color`` also resets ``pen.tile_fg`` and - ``pen.tile_bg`` to *nil*. - -In order to actually be able to paint to the screen, it is necessary -to create and register a viewscreen (basically a modal dialog) with -the game. - -.. warning:: - As a matter of policy, in order to avoid user confusion, all - interface screens added by dfhack should bear the "DFHack" signature. - -Screens are managed with the following functions: - -* ``dfhack.screen.show(screen[,below])`` - - Displays the given screen, possibly placing it below a different one. - The screen must not be already shown. Returns *true* if success. - -* ``dfhack.screen.dismiss(screen[,to_first])`` - - Marks the screen to be removed when the game enters its event loop. - If ``to_first`` is *true*, all screens up to the first one will be deleted. - -* ``dfhack.screen.isDismissed(screen)`` - - Checks if the screen is already marked for removal. - -Apart from a native viewscreen object, these functions accept a table -as a screen. In this case, ``show`` creates a new native viewscreen -that delegates all processing to methods stored in that table. - -.. note:: Lua-implemented screens are only supported in the core context. - -Supported callbacks and fields are: - -* ``screen._native`` - - Initialized by ``show`` with a reference to the backing viewscreen - object, and removed again when the object is deleted. - -* ``function screen:onShow()`` - - Called by ``dfhack.screen.show`` if successful. - -* ``function screen:onDismiss()`` - - Called by ``dfhack.screen.dismiss`` if successful. - -* ``function screen:onDestroy()`` - - Called from the destructor when the viewscreen is deleted. - -* ``function screen:onResize(w, h)`` - - Called before ``onRender`` or ``onIdle`` when the window size has changed. - -* ``function screen:onRender()`` - - Called when the viewscreen should paint itself. This is the only context - where the above painting functions work correctly. - - If omitted, the screen is cleared; otherwise it should do that itself. - In order to make a see-through dialog, call ``self._native.parent:render()``. - -* ``function screen:onIdle()`` - - Called every frame when the screen is on top of the stack. - -* ``function screen:onHelp()`` - - Called when the help keybinding is activated (usually '?'). - -* ``function screen:onInput(keys)`` - - Called when keyboard or mouse events are available. - If any keys are pressed, the keys argument is a table mapping them to *true*. - Note that this refers to logical keybingings computed from real keys via - options; if multiple interpretations exist, the table will contain multiple keys. - - The table also may contain special keys: - - ``_STRING`` - Maps to an integer in range 0-255. Duplicates a separate "STRING_A???" code for convenience. - - ``_MOUSE_L, _MOUSE_R`` - If the left or right mouse button is being pressed. - - ``_MOUSE_L_DOWN, _MOUSE_R_DOWN`` - If the left or right mouse button was just pressed. - - If this method is omitted, the screen is dismissed on receival of the ``LEAVESCREEN`` key. - -* ``function screen:onGetSelectedUnit()`` -* ``function screen:onGetSelectedItem()`` -* ``function screen:onGetSelectedJob()`` -* ``function screen:onGetSelectedBuilding()`` - - Implement these to provide a return value for the matching - ``dfhack.gui.getSelected...`` function. - - -PenArray class --------------- - -Screens that require significant computation in their onRender() method can use -a ``dfhack.penarray`` instance to cache their output. - -* ``dfhack.penarray.new(w, h)`` - - Creates a new penarray instance with an internal buffer of ``w * h`` tiles. - These dimensions currently cannot be changed after a penarray is instantiated. - -* ``penarray:clear()`` - - Clears the internal buffer, similar to ``dfhack.screen.clear()``. - -* ``penarray:get_dims()`` - - Returns the x and y dimensions of the internal buffer. - -* ``penarray:get_tile(x, y)`` - - Returns a pen corresponding to the tile at (``x``, ``y``) in the internal buffer. - Note that indices are 0-based. - -* ``penarray:set_tile(x, y, pen)`` - - Sets the tile at (``x``, ``y``) in the internal buffer to the pen given. - -* ``penarray:draw(x, y, w, h, bufferx, buffery)`` - - Draws the contents of the internal buffer, beginning at - (``bufferx``, ``buffery``) and spanning ``w`` columns and ``h`` rows, to the - screen starting at (``x``, ``y``). Any invalid screen and buffer coordinates - are skipped. - - ``bufferx`` and ``buffery`` default to 0. - -Filesystem module ------------------ - -Most of these functions return ``true`` on success and ``false`` on failure, -unless otherwise noted. - -* ``dfhack.filesystem.exists(path)`` - - Returns ``true`` if ``path`` exists. - -* ``dfhack.filesystem.isfile(path)`` - - Returns ``true`` if ``path`` exists and is a file. - -* ``dfhack.filesystem.isdir(path)`` - - Returns ``true`` if ``path`` exists and is a directory. - -* ``dfhack.filesystem.getcwd()`` - - Returns the current working directory. To retrieve the DF path, use ``dfhack.getDFPath()`` instead. - -* ``dfhack.filesystem.chdir(path)`` - - Changes the current directory to ``path``. Use with caution. - -* ``dfhack.filesystem.mkdir(path)`` - - Creates a new directory. Returns ``false`` if unsuccessful, including if ``path`` already exists. - -* ``dfhack.filesystem.rmdir(path)`` - - Removes a directory. Only works if the directory is already empty. - -* ``dfhack.filesystem.mtime(path)`` - - Returns the modification time (in seconds) of the file or directory specified by ``path``, - or -1 if ``path`` does not exist. This depends on the system clock and should only be used locally. - -* ``dfhack.filesystem.atime(path)`` -* ``dfhack.filesystem.ctime(path)`` - - Return values vary across operating systems - return the ``st_atime`` and ``st_ctime`` - fields of a C++ stat struct, respectively. - -* ``dfhack.filesystem.listdir(path)`` - - Lists files/directories in a directory. Returns ``{}`` if ``path`` does not exist. - -* ``dfhack.filesystem.listdir_recursive(path [, depth = 10])`` - - Lists all files/directories in a directory and its subdirectories. All directories - are listed before their contents. Returns a table with subtables of the format:: - - {path: 'path to file', isdir: true|false} - - Note that ``listdir()`` returns only the base name of each directory entry, while - ``listdir_recursive()`` returns the initial path and all components following it - for each entry. - -Internal API ------------- - -These functions are intended for the use by dfhack developers, -and are only documented here for completeness: - -* ``dfhack.internal.scripts`` - - The table used by ``dfhack.run_script()`` to give every script its own - global environment, persistent between calls to the script. - -* ``dfhack.internal.getPE()`` - - Returns the PE timestamp of the DF executable (only on Windows) - -* ``dfhack.internal.getMD5()`` - - Returns the MD5 of the DF executable (only on OS X and Linux) - -* ``dfhack.internal.getAddress(name)`` - - Returns the global address ``name``, or *nil*. - -* ``dfhack.internal.setAddress(name, value)`` - - Sets the global address ``name``. Returns the value of ``getAddress`` before the change. - -* ``dfhack.internal.getVTable(name)`` - - Returns the pre-extracted vtable address ``name``, or *nil*. - -* ``dfhack.internal.getImageBase()`` - - Returns the mmap base of the executable. - -* ``dfhack.internal.getRebaseDelta()`` - - Returns the ASLR rebase offset of the DF executable. - -* ``dfhack.internal.adjustOffset(offset[,to_file])`` - - Returns the re-aligned offset, or *nil* if invalid. - If ``to_file`` is true, the offset is adjusted from memory to file. - This function returns the original value everywhere except windows. - -* ``dfhack.internal.getMemRanges()`` - - Returns a sequence of tables describing virtual memory ranges of the process. - -* ``dfhack.internal.patchMemory(dest,src,count)`` - - Like memmove below, but works even if dest is read-only memory, e.g. code. - If destination overlaps a completely invalid memory region, or another error - occurs, returns false. - -* ``dfhack.internal.patchBytes(write_table[, verify_table])`` - - The first argument must be a lua table, which is interpreted as a mapping from - memory addresses to byte values that should be stored there. The second argument - may be a similar table of values that need to be checked before writing anything. - - The function takes care to either apply all of ``write_table``, or none of it. - An empty ``write_table`` with a nonempty ``verify_table`` can be used to reasonably - safely check if the memory contains certain values. - - Returns *true* if successful, or *nil, error_msg, address* if not. - -* ``dfhack.internal.memmove(dest,src,count)`` - - Wraps the standard memmove function. Accepts both numbers and refs as pointers. - -* ``dfhack.internal.memcmp(ptr1,ptr2,count)`` - - Wraps the standard memcmp function. - -* ``dfhack.internal.memscan(haystack,count,step,needle,nsize)`` - - Searches for ``needle`` of ``nsize`` bytes in ``haystack``, - using ``count`` steps of ``step`` bytes. - Returns: *step_idx, sum_idx, found_ptr*, or *nil* if not found. - -* ``dfhack.internal.diffscan(old_data, new_data, start_idx, end_idx, eltsize[, oldval, newval, delta])`` - - Searches for differences between buffers at ptr1 and ptr2, as integers of size eltsize. - The oldval, newval or delta arguments may be used to specify additional constraints. - Returns: *found_index*, or *nil* if end reached. - -* ``dfhack.internal.getDir(path)`` - - Lists files/directories in a directory. - Returns: *file_names* or empty table if not found. Identical to ``dfhack.filesystem.listdir(path)``. - -* ``dfhack.internal.strerror(errno)`` - - Wraps strerror() - returns a string describing a platform-specific error code - -* ``dfhack.internal.addScriptPath(path, search_before)`` - - Adds ``path`` to the list of paths searched for scripts (both in Lua and Ruby). - If ``search_before`` is passed and ``true``, the path will be searched before - the default paths (e.g. ``raw/scripts``, ``hack/scripts``); otherwise, it will - be searched after. - - Returns ``true`` if successful or ``false`` otherwise (e.g. if the path does - not exist or has already been registered). - -* ``dfhack.internal.removeScriptPath(path)`` - - Removes ``path`` from the script search paths and returns ``true`` if successful. - -* ``dfhack.internal.getScriptPaths()`` - - Returns the list of script paths in the order they are searched, including defaults. - (This can change if a world is loaded.) - -* ``dfhack.internal.findScript(name)`` - - Searches script paths for the script ``name`` and returns the path of the first - file found, or ``nil`` on failure. - - .. note:: - This requires an extension to be specified (``.lua`` or ``.rb``) - use - ``dfhack.findScript()`` to include the ``.lua`` extension automatically. - -Core interpreter context -======================== - -While plugins can create any number of interpreter instances, -there is one special context managed by dfhack core. It is the -only context that can receive events from DF and plugins. - -Core context specific functions: - -* ``dfhack.is_core_context`` - - Boolean value; *true* in the core context. - -* ``dfhack.timeout(time,mode,callback)`` - - Arranges for the callback to be called once the specified - period of time passes. The ``mode`` argument specifies the - unit of time used, and may be one of ``'frames'`` (raw FPS), - ``'ticks'`` (unpaused FPS), ``'days'``, ``'months'``, - ``'years'`` (in-game time). All timers other than - ``'frames'`` are cancelled when the world is unloaded, - and cannot be queued until it is loaded again. - Returns the timer id, or *nil* if unsuccessful due to - world being unloaded. - -* ``dfhack.timeout_active(id[,new_callback])`` - - Returns the active callback with the given id, or *nil* - if inactive or nil id. If called with 2 arguments, replaces - the current callback with the given value, if still active. - Using ``timeout_active(id,nil)`` cancels the timer. - -* ``dfhack.onStateChange.foo = function(code)`` - - Event. Receives the same codes as plugin_onstatechange in C++. - - -Event type ----------- - -An event is a native object transparently wrapping a lua table, -and implementing a __call metamethod. When it is invoked, it loops -through the table with next and calls all contained values. -This is intended as an extensible way to add listeners. - -This type itself is available in any context, but only the -core context has the actual events defined by C++ code. - -Features: - -* ``dfhack.event.new()`` - - Creates a new instance of an event. - -* ``event[key] = function`` - - Sets the function as one of the listeners. Assign *nil* to remove it. - - .. note:: - The ``df.NULL`` key is reserved for the use by - the C++ owner of the event; it is an error to try setting it. - -* ``#event`` - - Returns the number of non-nil listeners. - -* ``pairs(event)`` - - Iterates over all listeners in the table. - -* ``event(args...)`` - - Invokes all listeners contained in the event in an arbitrary - order using ``dfhack.safecall``. - - -=========== -Lua Modules -=========== - -.. contents:: - :local: - -DFHack sets up the lua interpreter so that the built-in ``require`` -function can be used to load shared lua code from :file:`hack/lua/`. -The ``dfhack`` namespace reference itself may be obtained via -``require('dfhack')``, although it is initially created as a -global by C++ bootstrap code. - -The following module management functions are provided: - -* ``mkmodule(name)`` - - Creates an environment table for the module. Intended to be used as:: - - local _ENV = mkmodule('foo') - ... - return _ENV - - If called the second time, returns the same table; thus providing reload support. - -* ``reload(name)`` - - Reloads a previously ``require``-d module *"name"* from the file. - Intended as a help for module development. - -* ``dfhack.BASE_G`` - - This variable contains the root global environment table, which is - used as a base for all module and script environments. Its contents - should be kept limited to the standard Lua library and API described - in this document. - -Global environment -================== - -A number of variables and functions are provided in the base global -environment by the mandatory init file dfhack.lua: - -* Color constants - - These are applicable both for ``dfhack.color()`` and color fields - in DF functions or structures:: - - COLOR_RESET, COLOR_BLACK, COLOR_BLUE, COLOR_GREEN, COLOR_CYAN, - COLOR_RED, COLOR_MAGENTA, COLOR_BROWN, COLOR_GREY, COLOR_DARKGREY, - COLOR_LIGHTBLUE, COLOR_LIGHTGREEN, COLOR_LIGHTCYAN, COLOR_LIGHTRED, - COLOR_LIGHTMAGENTA, COLOR_YELLOW, COLOR_WHITE - -* ``dfhack.onStateChange`` event codes - - Available only in the core context, as is the event itself: - - SC_WORLD_LOADED, SC_WORLD_UNLOADED, SC_MAP_LOADED, - SC_MAP_UNLOADED, SC_VIEWSCREEN_CHANGED, SC_CORE_INITIALIZED - -* Functions already described above - - safecall, qerror, mkmodule, reload - -* Miscellaneous constants - - ``NEWLINE``, ``COMMA``, ``PERIOD`` - evaluate to the relevant character strings. - ``DEFAULT_NIL`` - is an unspecified unique token used by the class module below. - -* ``printall(obj)`` - - If the argument is a lua table or DF object reference, prints all fields. - -* ``copyall(obj)`` - - Returns a shallow copy of the table or reference as a lua table. - -* ``pos2xyz(obj)`` - - The object must have fields x, y and z. Returns them as 3 values. - If obj is *nil*, or x is -30000 (the usual marker for undefined - coordinates), returns *nil*. - -* ``xyz2pos(x,y,z)`` - - Returns a table with x, y and z as fields. - -* ``same_xyz(a,b)`` - - Checks if ``a`` and ``b`` have the same x, y and z fields. - -* ``get_path_xyz(path,i)`` - - Returns ``path.x[i], path.y[i], path.z[i]``. - -* ``pos2xy(obj)``, ``xy2pos(x,y)``, ``same_xy(a,b)``, ``get_path_xy(a,b)`` - - Same as above, but for 2D coordinates. - -* ``safe_index(obj,index...)`` - - Walks a sequence of dereferences, which may be represented by numbers or strings. - Returns *nil* if any of obj or indices is *nil*, or a numeric index is out of array bounds. - -utils -===== - -* ``utils.compare(a,b)`` - - Comparator function; returns *-1* if ab, *0* otherwise. - -* ``utils.compare_name(a,b)`` - - Comparator for names; compares empty string last. - -* ``utils.is_container(obj)`` - - Checks if obj is a container ref. - -* ``utils.make_index_sequence(start,end)`` - - Returns a lua sequence of numbers in start..end. - -* ``utils.make_sort_order(data, ordering)`` - - Computes a sorted permutation of objects in data, as a table of integer - indices into the data sequence. Uses ``data.n`` as input length - if present. - - The ordering argument is a sequence of ordering specs, represented - as lua tables with following possible fields: - - ord.key = *function(value)* - Computes comparison key from input data value. Not called on nil. - If omitted, the comparison key is the value itself. - ord.key_table = *function(data)* - Computes a key table from the data table in one go. - ord.compare = *function(a,b)* - Comparison function. Defaults to ``utils.compare`` above. - Called on non-nil keys; nil sorts last. - ord.nil_first = *true/false* - If true, nil keys are sorted first instead of last. - ord.reverse = *true/false* - If true, sort non-nil keys in descending order. - - For every comparison during sorting the specs are applied in - order until an unambiguous decision is reached. Sorting is stable. - - Example of sorting a sequence by field foo:: - - local spec = { key = function(v) return v.foo end } - local order = utils.make_sort_order(data, { spec }) - local output = {} - for i = 1,#order do output[i] = data[order[i]] end - - Separating the actual reordering of the sequence in this - way enables applying the same permutation to multiple arrays. - This function is used by the sort plugin. - -* ``for link,item in utils.listpairs(list)`` - - Iterates a df-list structure, for example ``df.global.world.job_list``. - -* ``utils.assign(tgt, src)`` - - Does a recursive assignment of src into tgt. - Uses ``df.assign`` if tgt is a native object ref; otherwise - recurses into lua tables. - -* ``utils.clone(obj, deep)`` - - Performs a shallow, or semi-deep copy of the object as a lua table tree. - The deep mode recurses into lua tables and subobjects, except pointers - to other heap objects. - Null pointers are represented as ``df.NULL``. Zero-based native containers - are converted to 1-based lua sequences. - -* ``utils.clone_with_default(obj, default, force)`` - - Copies the object, using the ``default`` lua table tree - as a guide to which values should be skipped as uninteresting. - The ``force`` argument makes it always return a non-*nil* value. - -* ``utils.parse_bitfield_int(value, type_ref)`` - - Given an int ``value``, and a bitfield type in the ``df`` tree, - it returns a lua table mapping the enabled bit keys to *true*, - unless value is 0, in which case it returns *nil*. - -* ``utils.list_bitfield_flags(bitfield[, list])`` - - Adds all enabled bitfield keys to ``list`` or a newly-allocated - empty sequence, and returns it. The ``bitfield`` argument may - be *nil*. - -* ``utils.sort_vector(vector,field,cmpfun)`` - - Sorts a native vector or lua sequence using the comparator function. - If ``field`` is not *nil*, applies the comparator to the field instead - of the whole object. - -* ``utils.linear_index(vector,key[,field])`` - - Searches for ``key`` in the vector, and returns *index, found_value*, - or *nil* if none found. - -* ``utils.binsearch(vector,key,field,cmpfun,min,max)`` - - Does a binary search in a native vector or lua sequence for - ``key``, using ``cmpfun`` and ``field`` like sort_vector. - If ``min`` and ``max`` are specified, they are used as the - search subrange bounds. - - If found, returns *item, true, idx*. Otherwise returns - *nil, false, insert_idx*, where *insert_idx* is the correct - insertion point. - -* ``utils.insert_sorted(vector,item,field,cmpfun)`` - - Does a binary search, and inserts item if not found. - Returns *did_insert, vector[idx], idx*. - -* ``utils.insert_or_update(vector,item,field,cmpfun)`` - - Like ``insert_sorted``, but also assigns the item into - the vector cell if insertion didn't happen. - - As an example, you can use this to set skill values:: - - utils.insert_or_update(soul.skills, {new=true, id=..., rating=...}, 'id') - - (For an explanation of ``new=true``, see `lua-api-table-assignment`) - -* ``utils.erase_sorted_key(vector,key,field,cmpfun)`` - - Removes the item with the given key from the list. Returns: *did_erase, vector[idx], idx*. - -* ``utils.erase_sorted(vector,item,field,cmpfun)`` - - Exactly like ``erase_sorted_key``, but if field is specified, takes the key from ``item[field]``. - -* ``utils.call_with_string(obj,methodname,...)`` - - Allocates a temporary string object, calls ``obj:method(tmp,...)``, and - returns the value written into the temporary after deleting it. - -* ``utils.getBuildingName(building)`` - - Returns the string description of the given building. - -* ``utils.getBuildingCenter(building)`` - - Returns an x/y/z table pointing at the building center. - -* ``utils.split_string(string, delimiter)`` - - Splits the string by the given delimiter, and returns a sequence of results. - -* ``utils.prompt_yes_no(prompt, default)`` - - Presents a yes/no prompt to the user. If ``default`` is not *nil*, - allows just pressing Enter to submit the default choice. - If the user enters ``'abort'``, throws an error. - -* ``utils.prompt_input(prompt, checkfun, quit_str)`` - - Presents a prompt to input data, until a valid string is entered. - Once ``checkfun(input)`` returns *true, ...*, passes the values - through. If the user enters the quit_str (defaults to ``'~~~'``), - throws an error. - -* ``utils.check_number(text)`` - - A ``prompt_input`` ``checkfun`` that verifies a number input. - -dumper -====== - -A third-party lua table dumper module from -http://lua-users.org/wiki/DataDumper. Defines one -function: - -* ``dumper.DataDumper(value, varname, fastmode, ident, indent_step)`` - - Returns ``value`` converted to a string. The ``indent_step`` - argument specifies the indentation step size in spaces. For - the other arguments see the original documentation link above. - -class -===== - -Implements a trivial single-inheritance class system. - -* ``Foo = defclass(Foo[, ParentClass])`` - - Defines or updates class Foo. The ``Foo = defclass(Foo)`` syntax - is needed so that when the module or script is reloaded, the - class identity will be preserved through the preservation of - global variable values. - - The ``defclass`` function is defined as a stub in the global - namespace, and using it will auto-load the class module. - -* ``Class.super`` - - This class field is set by defclass to the parent class, and - allows a readable ``Class.super.method(self, ...)`` syntax for - calling superclass methods. - -* ``Class.ATTRS { foo = xxx, bar = yyy }`` - - Declares certain instance fields to be attributes, i.e. auto-initialized - from fields in the table used as the constructor argument. If omitted, - they are initialized with the default values specified in this declaration. - - If the default value should be *nil*, use ``ATTRS { foo = DEFAULT_NIL }``. - - Declaring an attribute is mostly the same as defining your ``init`` method like this:: - - function Class.init(args) - self.attr1 = args.attr1 or default1 - self.attr2 = args.attr2 or default2 - ... - end - - The main difference is that attributes are processed as a separate - initialization step, before any ``init`` methods are called. They - also make the directy relation between instance fields and constructor - arguments more explicit. - -* ``new_obj = Class{ foo = arg, bar = arg, ... }`` - - Calling the class as a function creates and initializes a new instance. - Initialization happens in this order: - - 1. An empty instance table is created, and its metatable set. - 2. The ``preinit`` methods are called via ``invoke_before`` (see below) - with the table used as argument to the class. These methods are intended - for validating and tweaking that argument table. - 3. Declared ATTRS are initialized from the argument table or their default values. - 4. The ``init`` methods are called via ``invoke_after`` with the argument table. - This is the main constructor method. - 5. The ``postinit`` methods are called via ``invoke_after`` with the argument table. - Place code that should be called after the object is fully constructed here. - -Predefined instance methods: - -* ``instance:assign{ foo = xxx }`` - - Assigns all values in the input table to the matching instance fields. - -* ``instance:callback(method_name, [args...])`` - - Returns a closure that invokes the specified method of the class, - properly passing in self, and optionally a number of initial arguments too. - The arguments given to the closure are appended to these. - -* ``instance:cb_getfield(field_name)`` - - Returns a closure that returns the specified field of the object when called. - -* ``instance:cb_setfield(field_name)`` - - Returns a closure that sets the specified field to its argument when called. - -* ``instance:invoke_before(method_name, args...)`` - - Navigates the inheritance chain of the instance starting from the most specific - class, and invokes the specified method with the arguments if it is defined in - that specific class. Equivalent to the following definition in every class:: - - function Class:invoke_before(method, ...) - if rawget(Class, method) then - rawget(Class, method)(self, ...) - end - Class.super.invoke_before(method, ...) - end - -* ``instance:invoke_after(method_name, args...)`` - - Like invoke_before, only the method is called after the recursive call to super, - i.e. invocations happen in the parent to child order. - - These two methods are inspired by the Common Lisp before and after methods, and - are intended for implementing similar protocols for certain things. The class - library itself uses them for constructors. - -To avoid confusion, these methods cannot be redefined. - -================== -In-game UI Library -================== - -.. contents:: - :local: - -A number of lua modules with names starting with ``gui`` are dedicated -to wrapping the natives of the ``dfhack.screen`` module in a way that -is easy to use. This allows relatively easily and naturally creating -dialogs that integrate in the main game UI window. - -These modules make extensive use of the ``class`` module, and define -things ranging from the basic ``Painter``, ``View`` and ``Screen`` -classes, to fully functional predefined dialogs. - -gui -=== - -This module defines the most important classes and functions for -implementing interfaces. This documents those of them that are -considered stable. - - -Misc ----- - -* ``USE_GRAPHICS`` - - Contains the value of ``dfhack.screen.inGraphicsMode()``, which cannot be - changed without restarting the game and thus is constant during the session. - -* ``CLEAR_PEN`` - - The black pen used to clear the screen. - -* ``simulateInput(screen, keys...)`` - - This function wraps an undocumented native function that passes a set of - keycodes to a screen, and is the official way to do that. - - Every argument after the initial screen may be *nil*, a numeric keycode, - a string keycode, a sequence of numeric or string keycodes, or a mapping - of keycodes to *true* or *false*. For instance, it is possible to use the - table passed as argument to ``onInput``. - -* ``mkdims_xy(x1,y1,x2,y2)`` - - Returns a table containing the arguments as fields, and also ``width`` and - ``height`` that contains the rectangle dimensions. - -* ``mkdims_wh(x1,y1,width,height)`` - - Returns the same kind of table as ``mkdims_xy``, only this time it computes - ``x2`` and ``y2``. - -* ``is_in_rect(rect,x,y)`` - - Checks if the given point is within a rectangle, represented by a table produced - by one of the ``mkdims`` functions. - -* ``blink_visible(delay)`` - - Returns *true* or *false*, with the value switching to the opposite every ``delay`` - msec. This is intended for rendering blinking interface objects. - -* ``getKeyDisplay(keycode)`` - - Wraps ``dfhack.screen.getKeyDisplay`` in order to allow using strings for the keycode argument. - - -ViewRect class --------------- - -This class represents an on-screen rectangle with an associated independent -clip area rectangle. It is the base of the ``Painter`` class, and is used by -``Views`` to track their client area. - -* ``ViewRect{ rect = ..., clip_rect = ..., view_rect = ..., clip_view = ... }`` - - The constructor has the following arguments: - - :rect: The ``mkdims`` rectangle in screen coordinates of the logical viewport. - Defaults to the whole screen. - :clip_rect: The clip rectangle in screen coordinates. Defaults to ``rect``. - :view_rect: A ViewRect object to copy from; overrides both ``rect`` and ``clip_rect``. - :clip_view: A ViewRect object to intersect the specified clip area with. - -* ``rect:isDefunct()`` - - Returns *true* if the clip area is empty, i.e. no painting is possible. - -* ``rect:inClipGlobalXY(x,y)`` - - Checks if these global coordinates are within the clip rectangle. - -* ``rect:inClipLocalXY(x,y)`` - - Checks if these coordinates (specified relative to ``x1,y1``) are within the clip rectangle. - -* ``rect:localXY(x,y)`` - - Converts a pair of global coordinates to local; returns *x_local,y_local*. - -* ``rect:globalXY(x,y)`` - - Converts a pair of local coordinates to global; returns *x_global,y_global*. - -* ``rect:viewport(x,y,w,h)`` or ``rect:viewport(subrect)`` - - Returns a ViewRect representing a sub-rectangle of the current one. - The arguments are specified in local coordinates; the ``subrect`` - argument must be a ``mkdims`` table. The returned object consists of - the exact specified rectangle, and a clip area produced by intersecting - it with the clip area of the original object. - - -Painter class -------------- - -The painting natives in ``dfhack.screen`` apply to the whole screen, are -completely stateless and don't implement clipping. - -The Painter class inherits from ViewRect to provide clipping and local -coordinates, and tracks current cursor position and current pen. - -* ``Painter{ ..., pen = ..., key_pen = ... }`` - - In addition to ViewRect arguments, Painter accepts a suggestion of - the initial value for the main pen, and the keybinding pen. They - default to COLOR_GREY and COLOR_LIGHTGREEN otherwise. - - There are also some convenience functions that wrap this constructor: - - - ``Painter.new(rect,pen)`` - - ``Painter.new_view(view_rect,pen)`` - - ``Painter.new_xy(x1,y1,x2,y2,pen)`` - - ``Painter.new_wh(x1,y1,width,height,pen)`` - -* ``painter:isValidPos()`` - - Checks if the current cursor position is within the clip area. - -* ``painter:viewport(x,y,w,h)`` - - Like the superclass method, but returns a Painter object. - -* ``painter:cursor()`` - - Returns the current cursor *x,y* in local coordinates. - -* ``painter:seek(x,y)`` - - Sets the current cursor position, and returns *self*. - Either of the arguments may be *nil* to keep the current value. - -* ``painter:advance(dx,dy)`` - - Adds the given offsets to the cursor position, and returns *self*. - Either of the arguments may be *nil* to keep the current value. - -* ``painter:newline([dx])`` - - Advances the cursor to the start of the next line plus the given x offset, and returns *self*. - -* ``painter:pen(...)`` - - Sets the current pen to ``dfhack.pen.parse(old_pen,...)``, and returns *self*. - -* ``painter:key_pen(...)`` - - Sets the current keybinding pen to ``dfhack.pen.parse(old_pen,...)``, and returns *self*. - -* ``painter:clear()`` - - Fills the whole clip rectangle with ``CLEAR_PEN``, and returns *self*. - -* ``painter:fill(x1,y1,x2,y2[,...])`` or ``painter:fill(rect[,...])`` - - Fills the specified local coordinate rectangle with ``dfhack.pen.parse(cur_pen,...)``, - and returns *self*. - -* ``painter:char([char[, ...]])`` - - Paints one character using ``char`` and ``dfhack.pen.parse(cur_pen,...)``; returns *self*. - The ``char`` argument, if not nil, is used to override the ``ch`` property of the pen. - -* ``painter:tile([char, tile[, ...]])`` - - Like above, but also allows overriding the ``tile`` property on ad-hoc basis. - -* ``painter:string(text[, ...])`` - - Paints the string with ``dfhack.pen.parse(cur_pen,...)``; returns *self*. - -* ``painter:key(keycode[, ...])`` - - Paints the description of the keycode using ``dfhack.pen.parse(cur_key_pen,...)``; returns *self*. - -As noted above, all painting methods return *self*, in order to allow chaining them like this:: - - painter:pen(foo):seek(x,y):char(1):advance(1):string('bar')... - - -View class ----------- - -This class is the common abstract base of both the stand-alone screens -and common widgets to be used inside them. It defines the basic layout, -rendering and event handling framework. - -The class defines the following attributes: - -:visible: Specifies that the view should be painted. -:active: Specifies that the view should receive events, if also visible. -:view_id: Specifies an identifier to easily identify the view among subviews. - This is reserved for implementation of top-level views, and should - not be used by widgets for their internal subviews. - -It also always has the following fields: - -:subviews: Contains a table of all subviews. The sequence part of the - table is used for iteration. In addition, subviews are also - indexed under their *view_id*, if any; see ``addviews()`` below. - -These fields are computed by the layout process: - -:frame_parent_rect: The ViewRect represeting the client area of the parent view. -:frame_rect: The ``mkdims`` rect of the outer frame in parent-local coordinates. -:frame_body: The ViewRect representing the body part of the View's own frame. - -The class has the following methods: - -* ``view:addviews(list)`` - - Adds the views in the list to the ``subviews`` sequence. If any of the views - in the list have ``view_id`` attributes that don't conflict with existing keys - in ``subviews``, also stores them under the string keys. Finally, copies any - non-conflicting string keys from the ``subviews`` tables of the listed views. - - Thus, doing something like this:: - - self:addviews{ - Panel{ - view_id = 'panel', - subviews = { - Label{ view_id = 'label' } - } - } - } - - Would make the label accessible as both ``self.subviews.label`` and - ``self.subviews.panel.subviews.label``. - -* ``view:getWindowSize()`` - - Returns the dimensions of the ``frame_body`` rectangle. - -* ``view:getMousePos()`` - - Returns the mouse *x,y* in coordinates local to the ``frame_body`` - rectangle if it is within its clip area, or nothing otherwise. - -* ``view:updateLayout([parent_rect])`` - - Recomputes layout of the view and its subviews. If no argument is - given, re-uses the previous parent rect. The process goes as follows: - - 1. Calls ``preUpdateLayout(parent_rect)`` via ``invoke_before``. - 2. Uses ``computeFrame(parent_rect)`` to compute the desired frame. - 3. Calls ``postComputeFrame(frame_body)`` via ``invoke_after``. - 4. Calls ``updateSubviewLayout(frame_body)`` to update children. - 5. Calls ``postUpdateLayout(frame_body)`` via ``invoke_after``. - -* ``view:computeFrame(parent_rect)`` *(for overriding)* - - Called by ``updateLayout`` in order to compute the frame rectangle(s). - Should return the ``mkdims`` rectangle for the outer frame, and optionally - also for the body frame. If only one rectangle is returned, it is used - for both frames, and the margin becomes zero. - -* ``view:updateSubviewLayout(frame_body)`` - - Calls ``updateLayout`` on all children. - -* ``view:render(painter)`` - - Given the parent's painter, renders the view via the following process: - - 1. Calls ``onRenderFrame(painter, frame_rect)`` to paint the outer frame. - 2. Creates a new painter using the ``frame_body`` rect. - 3. Calls ``onRenderBody(new_painter)`` to paint the client area. - 4. Calls ``renderSubviews(new_painter)`` to paint visible children. - -* ``view:renderSubviews(painter)`` - - Calls ``render`` on all ``visible`` subviews in the order they - appear in the ``subviews`` sequence. - -* ``view:onRenderFrame(painter, rect)`` *(for overriding)* - - Called by ``render`` to paint the outer frame; by default does nothing. - -* ``view:onRenderBody(painter)`` *(for overriding)* - - Called by ``render`` to paint the client area; by default does nothing. - -* ``view:onInput(keys)`` *(for overriding)* - - Override this to handle events. By default directly calls ``inputToSubviews``. - Return a true value from this method to signal that the event has been handled - and should not be passed on to more views. - -* ``view:inputToSubviews(keys)`` - - Calls ``onInput`` on all visible active subviews, iterating the ``subviews`` - sequence in *reverse order*, so that topmost subviews get events first. - Returns *true* if any of the subviews handled the event. - - -Screen class ------------- - -This is a View subclass intended for use as a stand-alone dialog or screen. -It adds the following methods: - -* ``screen:isShown()`` - - Returns *true* if the screen is currently in the game engine's display stack. - -* ``screen:isDismissed()`` - - Returns *true* if the screen is dismissed. - -* ``screen:isActive()`` - - Returns *true* if the screen is shown and not dismissed. - -* ``screen:invalidate()`` - - Requests a repaint. Note that currently using it is not necessary, because - repaints are constantly requested automatically, due to issues with native - screens happening otherwise. - -* ``screen:renderParent()`` - - Asks the parent native screen to render itself, or clears the screen if impossible. - -* ``screen:sendInputToParent(...)`` - - Uses ``simulateInput`` to send keypresses to the native parent screen. - -* ``screen:show([parent])`` - - Adds the screen to the display stack with the given screen as the parent; - if parent is not specified, places this one one topmost. Before calling - ``dfhack.screen.show``, calls ``self:onAboutToShow(parent)``. - -* ``screen:onAboutToShow(parent)`` *(for overriding)* - - Called when ``dfhack.screen.show`` is about to be called. - -* ``screen:onShow()`` - - Called by ``dfhack.screen.show`` once the screen is successfully shown. - -* ``screen:dismiss()`` - - Dismisses the screen. A dismissed screen does not receive any more - events or paint requests, but may remain in the display stack for - a short time until the game removes it. - -* ``screen:onDismiss()`` *(for overriding)* - - Called by ``dfhack.screen.dismiss()``. - -* ``screen:onDestroy()`` *(for overriding)* - - Called by the native code when the screen is fully destroyed and removed - from the display stack. Place code that absolutely must be called whenever - the screen is removed by any means here. - -* ``screen:onResize``, ``screen:onRender`` - - Defined as callbacks for native code. - - -FramedScreen class ------------------- - -A Screen subclass that paints a visible frame around its body. -Most dialogs should inherit from this class. - -A framed screen has the following attributes: - -:frame_style: A table that defines a set of pens to draw various parts of the frame. -:frame_title: A string to display in the middle of the top of the frame. -:frame_width: Desired width of the client area. If *nil*, the screen will occupy the whole width. -:frame_height: Likewise, for height. -:frame_inset: The gap between the frame and the client area. Defaults to 0. -:frame_background: The pen to fill in the frame with. Defaults to CLEAR_PEN. - -There are the following predefined frame style tables: - -* ``GREY_FRAME`` - - A plain grey-colored frame. - -* ``BOUNDARY_FRAME`` - - The same frame as used by the usual full-screen DF views, like dwarfmode. - -* ``GREY_LINE_FRAME`` - - A frame consisting of grey lines, similar to the one used by titan announcements. - - -gui.widgets -=========== - -This module implements some basic widgets based on the View infrastructure. - -Widget class ------------- - -Base of all the widgets. Inherits from View and has the following attributes: - -* ``frame = {...}`` - - Specifies the constraints on the outer frame of the widget. - If omitted, the widget will occupy the whole parent rectangle. - - The frame is specified as a table with the following possible fields: - - :l: gap between the left edges of the frame and the parent. - :t: gap between the top edges of the frame and the parent. - :r: gap between the right edges of the frame and the parent. - :b: gap between the bottom edges of the frame and the parent. - :w: maximum width of the frame. - :h: maximum heigth of the frame. - :xalign: X alignment of the frame. - :yalign: Y alignment of the frame. - - First the ``l,t,r,b`` fields restrict the available area for - placing the frame. If ``w`` and ``h`` are not specified or - larger then the computed area, it becomes the frame. Otherwise - the smaller frame is placed within the are based on the - ``xalign/yalign`` fields. If the align hints are omitted, they - are assumed to be 0, 1, or 0.5 based on which of the ``l/r/t/b`` - fields are set. - -* ``frame_inset = {...}`` - - Specifies the gap between the outer frame, and the client area. - The attribute may be a simple integer value to specify a uniform - inset, or a table with the following fields: - - :l: left margin. - :t: top margin. - :r: right margin. - :b: bottom margin. - :x: left/right margin, if ``l`` and/or ``r`` are omitted. - :y: top/bottom margin, if ``t`` and/or ``b`` are omitted. - -* ``frame_background = pen`` - - The pen to fill the outer frame with. Defaults to no fill. - -Panel class ------------ - -Inherits from Widget, and intended for grouping a number of subviews. - -Has attributes: - -* ``subviews = {}`` - - Used to initialize the subview list in the constructor. - -* ``on_render = function(painter)`` - - Called from ``onRenderBody``. - -Pages class ------------ - -Subclass of Panel; keeps exactly one child visible. - -* ``Pages{ ..., selected = ... }`` - - Specifies which child to select initially; defaults to the first one. - -* ``pages:getSelected()`` - - Returns the selected *index, child*. - -* ``pages:setSelected(index)`` - - Selects the specified child, hiding the previous selected one. - It is permitted to use the subview object, or its ``view_id`` as index. - -EditField class ---------------- - -Subclass of Widget; implements a simple edit field. - -Attributes: - -:text: The current contents of the field. -:text_pen: The pen to draw the text with. -:on_char: Input validation callback; used as ``on_char(new_char,text)``. - If it returns false, the character is ignored. -:on_change: Change notification callback; used as ``on_change(new_text,old_text)``. -:on_submit: Enter key callback; if set the field will handle the key and call ``on_submit(text)``. - -Label class ------------ - -This Widget subclass implements flowing semi-static text. - -It has the following attributes: - -:text_pen: Specifies the pen for active text. -:text_dpen: Specifies the pen for disabled text. -:text_hpen: Specifies the pen for text hovered over by the mouse, if a click handler is registered. -:disabled: Boolean or a callback; if true, the label is disabled. -:enabled: Boolean or a callback; if false, the label is disabled. -:auto_height: Sets self.frame.h from the text height. -:auto_width: Sets self.frame.w from the text width. -:on_click: A callback called when the label is clicked (optional) -:on_rclick: A callback called when the label is right-clicked (optional) - -The text itself is represented as a complex structure, and passed -to the object via the ``text`` argument of the constructor, or via -the ``setText`` method, as one of: - -* A simple string, possibly containing newlines. -* A sequence of tokens. - -Every token in the sequence in turn may be either a string, possibly -containing newlines, or a table with the following possible fields: - -* ``token.text = ...`` - - Specifies the main text content of a token, and may be a string, or - a callback returning a string. - -* ``token.gap = ...`` - - Specifies the number of character positions to advance on the line - before rendering the token. - -* ``token.tile = pen`` - - Specifies a pen to paint as one tile before the main part of the token. - -* ``token.width = ...`` - - If specified either as a value or a callback, the text field is padded - or truncated to the specified number. - -* ``token.pad_char = '?'`` - - If specified together with ``width``, the padding area is filled with - this character instead of just being skipped over. - -* ``token.key = '...'`` - - Specifies the keycode associated with the token. The string description - of the key binding is added to the text content of the token. - -* ``token.key_sep = '...'`` - - Specifies the separator to place between the keybinding label produced - by ``token.key``, and the main text of the token. If the separator is - '()', the token is formatted as ``text..' ('..binding..')'``. Otherwise - it is simply ``binding..sep..text``. - -* ``token.enabled``, ``token.disabled`` - - Same as the attributes of the label itself, but applies only to the token. - -* ``token.pen``, ``token.dpen`` - - Specify the pen and disabled pen to be used for the token's text. - The field may be either the pen itself, or a callback that returns it. - -* ``token.on_activate`` - - If this field is not nil, and ``token.key`` is set, the token will actually - respond to that key binding unless disabled, and call this callback. Eventually - this may be extended with mouse click support. - -* ``token.id`` - - Specifies a unique identifier for the token. - -* ``token.line``, ``token.x1``, ``token.x2`` - - Reserved for internal use. - -The Label widget implements the following methods: - -* ``label:setText(new_text)`` - - Replaces the text currently contained in the widget. - -* ``label:itemById(id)`` - - Finds a token by its ``id`` field. - -* ``label:getTextHeight()`` - - Computes the height of the text. - -* ``label:getTextWidth()`` - - Computes the width of the text. - -List class ----------- - -The List widget implements a simple list with paging. - -It has the following attributes: - -:text_pen: Specifies the pen for deselected list entries. -:cursor_pen: Specifies the pen for the selected entry. -:inactive_pen: If specified, used for the cursor when the widget is not active. -:icon_pen: Default pen for icons. -:on_select: Selection change callback; called as ``on_select(index,choice)``. - This is also called with *nil* arguments if ``setChoices`` is called - with an empty list. -:on_submit: Enter key callback; if specified, the list reacts to the key - and calls it as ``on_submit(index,choice)``. -:on_submit2: Shift-Enter key callback; if specified, the list reacts to the key - and calls it as ``on_submit2(index,choice)``. -:row_height: Height of every row in text lines. -:icon_width: If not *nil*, the specified number of character columns - are reserved to the left of the list item for the icons. -:scroll_keys: Specifies which keys the list should react to as a table. - -Every list item may be specified either as a string, or as a lua table -with the following fields: - -:text: Specifies the label text in the same format as the Label text. -:caption, [1]: Deprecated legacy aliases for **text**. -:text_*: Reserved for internal use. -:key: Specifies a keybinding that acts as a shortcut for the specified item. -:icon: Specifies an icon string, or a pen to paint a single character. May be a callback. -:icon_pen: When the icon is a string, used to paint it. - -The list supports the following methods: - -* ``List{ ..., choices = ..., selected = ... }`` - - Same as calling ``setChoices`` after construction. - -* ``list:setChoices(choices[, selected])`` - - Replaces the list of choices, possibly also setting the currently selected index. - -* ``list:setSelected(selected)`` - - Sets the currently selected index. Returns the index after validation. - -* ``list:getChoices()`` - - Returns the list of choices. - -* ``list:getSelected()`` - - Returns the selected *index, choice*, or nothing if the list is empty. - -* ``list:getContentWidth()`` - - Returns the minimal width to draw all choices without clipping. - -* ``list:getContentHeight()`` - - Returns the minimal width to draw all choices without scrolling. - -* ``list:submit()`` - - Call the ``on_submit`` callback, as if the Enter key was handled. - -* ``list:submit2()`` - - Call the ``on_submit2`` callback, as if the Shift-Enter key was handled. - -FilteredList class ------------------- - -This widget combines List, EditField and Label into a combo-box like -construction that allows filtering the list by subwords of its items. - -In addition to passing through all attributes supported by List, it -supports: - -:edit_pen: If specified, used instead of ``cursor_pen`` for the edit field. -:edit_below: If true, the edit field is placed below the list instead of above. -:not_found_label: Specifies the text of the label shown when no items match the filter. - -The list choices may include the following attributes: - -:search_key: If specified, used instead of **text** to match against the filter. - -The widget implements: - -* ``list:setChoices(choices[, selected])`` - - Resets the filter, and passes through to the inner list. - -* ``list:getChoices()`` - - Returns the list of *all* choices. - -* ``list:getFilter()`` - - Returns the current filter string, and the *filtered* list of choices. - -* ``list:setFilter(filter[,pos])`` - - Sets the new filter string, filters the list, and selects the item at - index ``pos`` in the *unfiltered* list if possible. - -* ``list:canSubmit()`` - - Checks if there are currently any choices in the filtered list. - -* ``list:getSelected()``, ``list:getContentWidth()``, ``list:getContentHeight()``, ``list:submit()`` - - Same as with an ordinary list. - - -======= -Plugins -======= - -.. contents:: - :local: - -DFHack plugins may export native functions and events -to lua contexts. They are automatically imported by -``mkmodule('plugins.')``; this means that a lua -module file is still necessary for ``require`` to read. - -The following plugins have lua support. - -burrows -======= - -Implements extended burrow manipulations. - -Events: - -* ``onBurrowRename.foo = function(burrow)`` - - Emitted when a burrow might have been renamed either through - the game UI, or ``renameBurrow()``. - -* ``onDigComplete.foo = function(job_type,pos,old_tiletype,new_tiletype,worker)`` - - Emitted when a tile might have been dug out. Only tracked if the - auto-growing burrows feature is enabled. - -Native functions: - -* ``renameBurrow(burrow,name)`` - - Renames the burrow, emitting ``onBurrowRename`` and updating auto-grow state properly. - -* ``findByName(burrow,name)`` - - Finds a burrow by name, using the same rules as the plugin command line interface. - Namely, trailing ``'+'`` characters marking auto-grow burrows are ignored. - -* ``copyUnits(target,source,enable)`` - - Applies units from ``source`` burrow to ``target``. The ``enable`` - parameter specifies if they are to be added or removed. - -* ``copyTiles(target,source,enable)`` - - Applies tiles from ``source`` burrow to ``target``. The ``enable`` - parameter specifies if they are to be added or removed. - -* ``setTilesByKeyword(target,keyword,enable)`` - - Adds or removes tiles matching a predefined keyword. The keyword - set is the same as used by the command line. - -The lua module file also re-exports functions from ``dfhack.burrows``. - -sort -==== - -Does not export any native functions as of now. Instead, it -calls lua code to perform the actual ordering of list items. - -.. _eventful: - -Eventful -======== - -This plugin exports some events to lua thus allowing to run lua functions -on DF world events. - -List of events --------------- - -1. ``onReactionComplete(reaction,reaction_product,unit,input_items,input_reagents,output_items,call_native)`` - - Auto activates if detects reactions starting with ``LUA_HOOK_``. Is called when reaction finishes. - -2. ``onItemContaminateWound(item,unit,wound,number1,number2)`` - - Is called when item tries to contaminate wound (e.g. stuck in). - -3. ``onProjItemCheckMovement(projectile)`` - - Is called when projectile moves. - -4. ``onProjItemCheckImpact(projectile,somebool)`` - - Is called when projectile hits something. - -5. ``onProjUnitCheckMovement(projectile)`` - - Is called when projectile moves. - -6. ``onProjUnitCheckImpact(projectile,somebool)`` - - Is called when projectile hits something. - -7. ``onWorkshopFillSidebarMenu(workshop,callnative)`` - - Is called when viewing a workshop in 'q' mode, to populate reactions, useful for custom viewscreens for shops. - -8. ``postWorkshopFillSidebarMenu(workshop)`` - - Is called after calling (or not) native fillSidebarMenu(). Useful for job button - tweaking (e.g. adding custom reactions) - -.. _EventManager: - -Events from EventManager ------------------------- -These events are straight from EventManager module. Each of them first needs to be enabled. See functions for more info. If you register a listener before the game is loaded, be aware that no events will be triggered immediately after loading, so you might need to add another event listener for when the game first loads in some cases. - -1. ``onBuildingCreatedDestroyed(building_id)`` - - Gets called when building is created or destroyed. - -2. ``onConstructionCreatedDestroyed(building_id)`` - - Gets called when construction is created or destroyed. - -3. ``onJobInitiated(job)`` - - Gets called when job is issued. - -4. ``onJobCompleted(job)`` - - Gets called when job is finished. The job that is passed to this function is a copy. Requires a frequency of 0 in order to distinguish between workshop jobs that were cancelled by the user and workshop jobs that completed successfully. - -5. ``onUnitDeath(unit_id)`` - - Gets called on unit death. - -6. ``onItemCreated(item_id)`` - - Gets called when item is created (except due to traders, migrants, invaders and spider webs). - -7. ``onSyndrome(unit_id,syndrome_index)`` - - Gets called when new syndrome appears on a unit. - -8. ``onInvasion(invasion_id)`` - - Gets called when new invasion happens. - -9. ``onInventoryChange(unit_id,item_id,old_equip,new_equip)`` - - Gets called when someone picks up an item, puts one down, or changes the way they are holding it. If an item is picked up, old_equip will be null. If an item is dropped, new_equip will be null. If an item is re-equipped in a new way, then neither will be null. You absolutely must NOT alter either old_equip or new_equip or you might break other plugins. - -10. ``onReport(reportId)`` - - Gets called when a report happens. This happens more often than you probably think, even if it doesn't show up in the announcements. - -11. ``onUnitAttack(attackerId, defenderId, woundId)`` - - Called when a unit wounds another with a weapon. Is NOT called if blocked, dodged, deflected, or parried. - -12. ``onUnload()`` - - A convenience event in case you don't want to register for every onStateChange event. - -13. ``onInteraction(attackVerb, defendVerb, attackerId, defenderId, attackReportId, defendReportId)`` - - Called when a unit uses an interaction on another. - -Functions ---------- - -1. ``registerReaction(reaction_name,callback)`` - - Simplified way of using onReactionComplete; the callback is function (same params as event). - -2. ``removeNative(shop_name)`` - - Removes native choice list from the building. - -3. ``addReactionToShop(reaction_name,shop_name)`` - - Add a custom reaction to the building. - -4. ``enableEvent(evType,frequency)`` - - Enable event checking for EventManager events. For event types use ``eventType`` table. Note that different types of events require different frequencies to be effective. The frequency is how many ticks EventManager will wait before checking if that type of event has happened. If multiple scripts or plugins use the same event type, the smallest frequency is the one that is used, so you might get events triggered more often than the frequency you use here. - -5. ``registerSidebar(shop_name,callback)`` - - Enable callback when sidebar for ``shop_name`` is drawn. Usefull for custom workshop views e.g. using gui.dwarfmode lib. Also accepts a ``class`` instead of function - as callback. Best used with ``gui.dwarfmode`` class ``WorkshopOverlay``. - -Examples --------- -Spawn dragon breath on each item attempt to contaminate wound:: - - b=require "plugins.eventful" - b.onItemContaminateWound.one=function(item,unit,un_wound,x,y) - local flw=dfhack.maps.spawnFlow(unit.pos,6,0,0,50000) - end - -Reaction complete example:: - - b=require "plugins.eventful" - - b.registerReaction("LUA_HOOK_LAY_BOMB",function(reaction,unit,in_items,in_reag,out_items,call_native) - local pos=copyall(unit.pos) - -- spawn dragonbreath after 100 ticks - dfhack.timeout(100,"ticks",function() dfhack.maps.spawnFlow(pos,6,0,0,50000) end) - --do not call real item creation code - call_native.value=false - end) - -Grenade example:: - - b=require "plugins.eventful" - b.onProjItemCheckImpact.one=function(projectile) - -- you can check if projectile.item e.g. has correct material - dfhack.maps.spawnFlow(projectile.cur_pos,6,0,0,50000) - end - -Integrated tannery:: - - b=require "plugins.eventful" - b.addReactionToShop("TAN_A_HIDE","LEATHERWORKS") - -.. _building-hacks: - -Building-hacks -============== - -This plugin overwrites some methods in workshop df class so that mechanical workshops are possible. Although -plugin export a function it's recommended to use lua decorated function. - -Functions ---------- - -``registerBuilding(table)`` where table must contain name, as a workshop raw name, the rest are optional: - - :name: - custom workshop id e.g. ``SOAPMAKER`` - - .. note:: this is the only mandatory field. - - :fix_impassible: - if true make impassible tiles impassible to liquids too - :consume: - how much machine power is needed to work. - Disables reactions if not supplied enough and ``needs_power==1`` - :produce: - how much machine power is produced. - :needs_power: - if produced in network < consumed stop working, default true - :gears: - a table or ``{x=?,y=?}`` of connection points for machines. - :action: - a table of number (how much ticks to skip) and a function which - gets called on shop update - :animate: - a table of frames which can be a table of: - - a. tables of 4 numbers ``{tile,fore,back,bright}`` OR - b. empty table (tile not modified) OR - c. ``{x= y= + 4 numbers like in first case}``, - this generates full frame useful for animations that change little (1-2 tiles) - - :canBeRoomSubset: - a flag if this building can be counted in room. 1 means it can, 0 means it can't and -1 default building behaviour - :auto_gears: - a flag that automatically fills up gears and animate. It looks over building definition for gear icons and maps them. - - Animate table also might contain: - - :frameLength: - how many ticks does one frame take OR - :isMechanical: - a bool that says to try to match to mechanical system (i.e. how gears are turning) - -``getPower(building)`` returns two number - produced and consumed power if building can be modified and returns nothing otherwise - -``setPower(building,produced,consumed)`` sets current productiona and consumption for a building. - -Examples --------- - -Simple mechanical workshop:: - - require('plugins.building-hacks').registerBuilding{name="BONE_GRINDER", - consume=15, - gears={x=0,y=0}, --connection point - animate={ - isMechanical=true, --animate the same conn. point as vanilla gear - frames={ - {{x=0,y=0,42,7,0,0}}, --first frame, 1 changed tile - {{x=0,y=0,15,7,0,0}} -- second frame, same - } - } - -Or with auto_gears:: - - require('plugins.building-hacks').registerBuilding{name="BONE_GRINDER", - consume=15, - auto_gears=true - } - -Luasocket -========= - -A way to access csocket from lua. The usage is made similar to luasocket in vanilla lua distributions. Currently -only subset of functions exist and only tcp mode is implemented. - -Socket class ------------- - -This is a base class for ``client`` and ``server`` sockets. You can not create it - it's like a virtual -base class in c++. - - -* ``socket:close()`` - - Closes the connection. - -* ``socket:setTimeout(sec,msec)`` - - Sets the operation timeout for this socket. It's possible to set timeout to 0. Then it performs like - a non-blocking socket. - -Client class ------------- - -Client is a connection socket to a server. You can get this object either from ``tcp:connect(address,port)`` or -from ``server:accept()``. It's a subclass of ``socket``. - -* ``client:receive(pattern)`` - - Receives data. Pattern is one of: - - :``*l``: read one line (default, if pattern is *nil*) - :: read specified number of bytes - :``*a``: read all available data - -* ``client:send(data)`` - - Sends data. Data is a string. - - -Server class ------------- - -Server is a socket that is waiting for clients. -You can get this object from ``tcp:bind(address,port)``. - -* ``server:accept()`` - - Accepts an incoming connection if it exists. - Returns a ``client`` object representing that socket. - -Tcp class ---------- - -A class with all the tcp functionality. - -* ``tcp:bind(address,port)`` - - Starts listening on that port for incoming connections. Returns ``server`` object. - -* ``tcp:connect(address,port)`` - - Tries connecting to that address and port. Returns ``client`` object. - - -======= -Scripts -======= - -.. contents:: - :local: - -Any files with the .lua extension placed into :file:`hack/scripts/*` -are automatically used by the DFHack core as commands. The -matching command name consists of the name of the file without -the extension. First DFHack searches for the script in the :file:`/raw/scripts/` folder. If it is not found there, it searches in the :file:`/raw/scripts/` folder. If it is not there, it searches in -:file:`/hack/scripts/`. If it is not there, it gives up. - -If the first line of the script is a one-line comment, it is -used by the built-in ``ls`` and ``help`` commands. -Such a comment is required for every script in the official DFHack repository. - -.. note:: - Scripts placed in subdirectories still can be accessed, but - do not clutter the `ls` command list (unless ``ls -a``; thus it is preferred - for obscure developer-oriented scripts and scripts used by tools. - When calling such scripts, always use '/' as the separator for - directories, e.g. ``devel/lua-example``. - -Scripts are re-read from disk if they have changed since the last time they were read. -Global variable values persist in memory between calls, unless the file has changed. -Every script gets its own separate environment for global -variables. - -Arguments are passed in to the scripts via the **...** built-in -quasi-variable; when the script is called by the DFHack core, -they are all guaranteed to be non-nil strings. - -DFHack core invokes the scripts in the *core context* (see above); -however it is possible to call them from any lua code (including -from other scripts) in any context, via the same function the core uses: - -* ``dfhack.run_script(name[,args...])`` - - Run a lua script in hack/scripts/, as if it was started from dfhack command-line. - The ``name`` argument should be the name stem, as would be used on the command line. - -Note that this function lets errors propagate to the caller. - -* ``dfhack.script_environment(name)`` - - Run an Lua script and return its environment. - This command allows you to use scripts like modules for increased portability. - It is highly recommended that if you are a modder you put your custom modules in ``raw/scripts`` and use ``script_environment`` instead of ``require`` so that saves with your mod installed will be self-contained and can be transferred to people who do have DFHack but do not have your mod installed. - - You can say ``dfhack.script_environment('add-thought').addEmotionToUnit([arguments go here])`` and it will have the desired effect. - It will call the script in question with the global ``moduleMode`` set to ``true`` so that the script can return early. - This is useful because if the script is called from the console it should deal with its console arguments and if it is called by ``script_environment`` it should only create its global functions and return. - You can also access global variables with, for example ``print(dfhack.script_environment('add-thought').validArgs)`` - - The function ``script_environment`` is fast enough that it is recommended that you not store its result in a nonlocal variable, because your script might need to load a different version of that script if the save is unloaded and a save with a different mod that overrides the same script with a slightly different functionality is loaded. - This will not be an issue in most cases. - - This function also permits circular dependencies of scripts. - -* ``dfhack.reqscript(name)`` or ``reqscript(name)`` - - Nearly identical to script_environment() but requires scripts being loaded to - include a line similar to:: - - --@ module = true - - This is intended to only allow scripts that take appropriate action when used - as a module to be loaded. - -Enabling and disabling scripts -============================== - -Scripts can choose to recognize the built-in ``enable`` and ``disable`` commands -by including the following line anywhere in their file:: - - --@ enable = true - -When the ``enable`` and ``disable`` commands are invoked, a ``dfhack_flags`` -table will be passed to the script with the following fields set: - -* ``enable``: Always true if the script is being enabled *or* disabled -* ``enable_state``: True if the script is being enabled, false otherwise - -Save init script -================ - -If a save directory contains a file called ``raw/init.lua``, it is -automatically loaded and executed every time the save is loaded. -The same applies to any files called ``raw/init.d/*.lua``. Every -such script can define the following functions to be called by dfhack: - -* ``function onStateChange(op) ... end`` - - Automatically called from the regular onStateChange event as long - as the save is still loaded. This avoids the need to install a hook - into the global ``dfhack.onStateChange`` table, with associated - cleanup concerns. - -* ``function onUnload() ... end`` - - Called when the save containing the script is unloaded. This function - should clean up any global hooks installed by the script. Note that - when this is called, the world is already completely unloaded. - -Within the init script, the path to the save directory is available as ``SAVE_PATH``. diff --git a/docs/NEWS-dev.rst b/docs/NEWS-dev.rst new file mode 100644 index 0000000000..f77b1b4f51 --- /dev/null +++ b/docs/NEWS-dev.rst @@ -0,0 +1,20 @@ +.. comment + This is the changelog for development releases. Entries are included from + changelog.txt. + +.. _dev-changelog: + +##################### +Development changelog +##################### + +This file contains changes grouped by the release (stable or development) in +which they first appeared. See `build-changelog` for more information. + +See `changelog` for a list of changes grouped by stable releases. + +.. contents:: Contents + :local: + :depth: 1 + +.. include:: /docs/changelogs/news-dev.rst diff --git a/docs/NEWS.rst b/docs/NEWS.rst new file mode 100644 index 0000000000..41e64b339b --- /dev/null +++ b/docs/NEWS.rst @@ -0,0 +1,27 @@ +.. comment + This is the changelog for stable releases. Entries are included from + changelog.txt. + +.. _changelog: + +######### +Changelog +######### + +This file contains changes grouped by the stable release in which they first +appeared. See `build-changelog` for more information. + +See `dev-changelog` for a list of changes grouped by development releases. + +.. contents:: Contents + :local: + :depth: 1 + +.. include:: /docs/changelogs/news.rst + + +Older Changelogs +================ +Are kept in a separate file: `History` + +.. that's ``docs/about/History.rst``, if you're reading the raw text. diff --git a/docs/Plugins.rst b/docs/Plugins.rst deleted file mode 100644 index ba502c38e5..0000000000 --- a/docs/Plugins.rst +++ /dev/null @@ -1,2440 +0,0 @@ -############## -DFHack Plugins -############## - -DFHack plugins are the commands, that are compiled with a specific version. -They can provide anything from a small keybinding, to a complete overhaul of -game subsystems or the entire renderer. - -Most commands offered by plugins are listed here, -hopefully organised in a way you will find useful. - -.. contents:: - :depth: 2 - -=============================== -Data inspection and visualizers -=============================== - -.. contents:: - :local: - -.. _plugin-stonesense: - -stonesense -========== -An isometric visualizer that runs in a second window. Usage: - -:stonesense: Open the visualiser in a new window. Alias ``ssense``. -:ssense overlay: Overlay DF window, replacing the map area. - -For more information, see `the full Stonesense README `. - -.. _blueprint: - -blueprint -========= -Exports a portion of your fortress into QuickFort style blueprint files.:: - - blueprint [dig] [build] [place] [query] - -Options (If only region and name are given, export all): - -:x,y,z: Size of map area to export -:name: Name of export files -:dig: Export dig commands to "-dig.csv" -:build: Export build commands to "-build.csv" -:place: Export stockpile commands to "-place.csv" -:query: Export query commands to "-query.csv" - -Goes very well with `fortplan`, for re-importing. - -.. _remotefortressreader: - -remotefortressreader -==================== -An in-development plugin for realtime fortress visualisation. -See :forums:`Armok Vision <146473>`. - - -cursecheck -========== -Checks a single map tile or the whole map/world for cursed creatures (ghosts, -vampires, necromancers, werebeasts, zombies). - -With an active in-game cursor only the selected tile will be observed. -Without a cursor the whole map will be checked. - -By default cursed creatures will be only counted in case you just want to find -out if you have any of them running around in your fort. Dead and passive -creatures (ghosts who were put to rest, killed vampires, ...) are ignored. -Undead skeletons, corpses, bodyparts and the like are all thrown into the curse -category "zombie". Anonymous zombies and resurrected body parts will show -as "unnamed creature". - -Options: - -:detail: Print full name, date of birth, date of curse and some status - info (some vampires might use fake identities in-game, though). -:nick: Set the type of curse as nickname (does not always show up - in-game, some vamps don't like nicknames). -:all: Include dead and passive cursed creatures (can result in a quite - long list after having FUN with necromancers). -:verbose: Print all curse tags (if you really want to know it all). - -Examples: - -``cursecheck detail all`` - Give detailed info about all cursed creatures including deceased ones (no - in-game cursor). -``cursecheck nick`` - Give a nickname all living/active cursed creatures on the map(no in-game - cursor). - -.. note:: - - If you do a full search (with the option "all") former ghosts will show up - with the cursetype "unknown" because their ghostly flag is not set. - - Please report any living/active creatures with cursetype "unknown" - - this is most likely with mods which introduce new types of curses. - -flows -===== -A tool for checking how many tiles contain flowing liquids. If you suspect that -your magma sea leaks into HFS, you can use this tool to be sure without -revealing the map. - -probe -===== -Can be used to determine tile properties like temperature. - -.. _prospect: - -prospect -======== -Prints a big list of all the present minerals and plants. By default, only -the visible part of the map is scanned. - -Options: - -:all: Scan the whole map, as if it was revealed. -:value: Show material value in the output. Most useful for gems. -:hell: Show the Z range of HFS tubes. Implies 'all'. - -If prospect is called during the embark selection screen, it displays an estimate of -layer stone availability. - -.. note:: - - The results of pre-embark prospect are an *estimate*, and can at best be expected - to be somewhere within +/- 30% of the true amount; sometimes it does a lot worse. - Especially, it is not clear how to precisely compute how many soil layers there - will be in a given embark tile, so it can report a whole extra layer, or omit one - that is actually present. - -Options: - -:all: Also estimate vein mineral amounts. - -.. _reveal: -.. _unreveal: -.. _revtoggle: -.. _revflood: -.. _revforget: - -reveal -====== -This reveals the map. By default, HFS will remain hidden so that the demons -don't spawn. You can use ``reveal hell`` to reveal everything. With hell revealed, -you won't be able to unpause until you hide the map again. If you really want -to unpause with hell revealed, use ``reveal demons``. - -Reveal also works in adventure mode, but any of its effects are negated once -you move. When you use it this way, you don't need to run ``unreveal``. - -Usage and related commands: - -:reveal: Reveal the whole map, except for HFS to avoid demons spawning -:reveal hell: Also show hell, but requires ``unreveal`` before unpausing -:reveal demon: Reveals everything and allows unpausing - good luck! -:unreveal: Reverts the effects of ``reveal`` -:revtoggle: Switches between ``reveal`` and ``unreveal`` -:revflood: Hide everything, then reveal tiles with a path to the cursor - (useful to make walled-off rooms vanish) -:revforget: Discard info about what was visible before revealing the map. - Only useful where (eg) you abandoned with the fort revealed - and no longer want the data. - -.. _showmood: - -showmood -======== -Shows all items needed for the currently active strange mood. - - -======== -Bugfixes -======== - -.. contents:: - :local: - -.. _fix-unit-occupancy: - -fix-unit-occupancy -================== -This plugin fixes issues with unit occupancy, notably phantom -"unit blocking tile" messages (:bug:`3499`). It can be run manually, or -periodically when enabled with the built-in enable/disable commands: - -:(no argument): Run the plugin once immediately, for the whole map. -:-h, here, cursor: Run immediately, only operate on the tile at the cursor -:-n, dry, dry-run: Run immediately, do not write changes to map -:interval : Run the plugin every ``X`` ticks (when enabled). - The default is 1200 ticks, or 1 day. - Ticks are only counted when the game is unpaused. - -.. _fixveins: - -fixveins -======== -Removes invalid references to mineral inclusions and restores missing ones. -Use this if you broke your embark with tools like `tiletypes`, or if you -accidentally placed a construction on top of a valuable mineral floor. - -.. _petcapRemover: - -petcapRemover -============= -Allows you to remove or raise the pet population cap. In vanilla -DF, pets will not reproduce unless the population is below 50 and the number of -children of that species is below a certain percentage. This plugin allows -removing the second restriction and removing or raising the first. Pets still -require PET or PET_EXOTIC tags in order to reproduce. Type ``help petcapRemover`` -for exact usage. In order to make population more stable and avoid sudden -population booms as you go below the raised population cap, this plugin counts -pregnancies toward the new population cap. It can still go over, but only in the -case of multiple births. - -Usage: - -:petcapRemover: cause pregnancies now and schedule the next check -:petcapRemover every n: set how often in ticks the plugin checks for possible pregnancies -:petcapRemover cap n: set the new cap to n. if n = 0, no cap -:petcapRemover pregtime n: sets the pregnancy duration to n ticks. natural pregnancies are - 300000 ticks for the current race and 200000 for everyone else - -.. _tweak: - -tweak -===== -Contains various tweaks for minor bugs. - -One-shot subcommands: - -:clear-missing: Remove the missing status from the selected unit. - This allows engraving slabs for ghostly, but not yet - found, creatures. -:clear-ghostly: Remove the ghostly status from the selected unit and mark - it as dead. This allows getting rid of bugged ghosts - which do not show up in the engraving slab menu at all, - even after using clear-missing. It works, but is - potentially very dangerous - so use with care. Probably - (almost certainly) it does not have the same effects like - a proper burial. You've been warned. -:fixmigrant: Remove the resident/merchant flag from the selected unit. - Intended to fix bugged migrants/traders who stay at the - map edge and don't enter your fort. Only works for - dwarves (or generally the player's race in modded games). - Do NOT abuse this for 'real' caravan merchants (if you - really want to kidnap them, use 'tweak makeown' instead, - otherwise they will have their clothes set to forbidden etc). -:makeown: Force selected unit to become a member of your fort. - Can be abused to grab caravan merchants and escorts, even if - they don't belong to the player's race. Foreign sentients - (humans, elves) can be put to work, but you can't assign rooms - to them and they don't show up in DwarfTherapist because the - game treats them like pets. Grabbing draft animals from - a caravan can result in weirdness (animals go insane or berserk - and are not flagged as tame), but you are allowed to mark them - for slaughter. Grabbing wagons results in some funny spam, then - they are scuttled. - -Subcommands that persist until disabled or DF quits: - -:adamantine-cloth-wear: Prevents adamantine clothing from wearing out while being worn (:bug:`6481`). -:advmode-contained: Works around :bug:`6202`, custom reactions with container inputs - in advmode. The issue is that the screen tries to force you to select - the contents separately from the container. This forcefully skips child - reagents. -:block-labors: Prevents labors that can't be used from being toggled -:civ-view-agreement: Fixes overlapping text on the "view agreement" screen -:craft-age-wear: Fixes the behavior of crafted items wearing out over time (:bug:`6003`). - With this tweak, items made from cloth and leather will gain a level of - wear every 20 years. -:embark-profile-name: Allows the use of lowercase letters when saving embark profiles -:eggs-fertile: Displays a fertility indicator on nestboxes -:farm-plot-select: Adds "Select all" and "Deselect all" options to farm plot menus -:fast-heat: Further improves temperature update performance by ensuring that 1 degree - of item temperature is crossed in no more than specified number of frames - when updating from the environment temperature. This reduces the time it - takes for stable-temp to stop updates again when equilibrium is disturbed. -:fast-trade: Makes Shift-Down in the Move Goods to Depot and Trade screens select - the current item (fully, in case of a stack), and scroll down one line. -:fps-min: Fixes the in-game minimum FPS setting -:hide-priority: Adds an option to hide designation priority indicators -:import-priority-category: - Allows changing the priority of all goods in a - category when discussing an import agreement with the liaison -:kitchen-keys: Fixes DF kitchen meal keybindings (:bug:`614`) -:kitchen-prefs-color: Changes color of enabled items to green in kitchen preferences -:kitchen-prefs-empty: Fixes a layout issue with empty kitchen tabs (:bug:`9000`) -:max-wheelbarrow: Allows assigning more than 3 wheelbarrows to a stockpile -:military-color-assigned: - Color squad candidates already assigned to other squads in yellow/green - to make them stand out more in the list. - - .. image:: images/tweak-mil-color.png - -:military-stable-assign: - Preserve list order and cursor position when assigning to squad, - i.e. stop the rightmost list of the Positions page of the military - screen from constantly resetting to the top. -:nestbox-color: Fixes the color of built nestboxes -:shift-8-scroll: Gives Shift-8 (or :kbd:`*`) priority when scrolling menus, instead of scrolling the map -:stable-cursor: Saves the exact cursor position between t/q/k/d/b/etc menus of fortress mode. -:title-start-rename: Adds a safe rename option to the title screen "Start Playing" menu -:tradereq-pet-gender: Displays pet genders on the trade request screen - -.. _fix-armory: - -fix-armory -========== -`This plugin requires a binpatch `, which has not -been available since DF 0.34.11 - - -=========== -UI Upgrades -=========== - -.. note:: - In order to avoid user confusion, as a matter of policy all GUI tools - display the word :guilabel:`DFHack` on the screen somewhere while active. - - When that is not appropriate because they merely add keybinding hints to - existing DF screens, they deliberately use red instead of green for the key. - -.. contents:: - :local: - - -.. _automelt: - -automelt -======== -When automelt is enabled for a stockpile, any meltable items placed -in it will be designated to be melted. -This plugin adds an option to the :kbd:`q` menu when `enabled `. - -.. _autotrade: - -autotrade -========= -When autotrade is enabled for a stockpile, any items placed in it will be -designated to be taken to the Trade Depot whenever merchants are on the map. -This plugin adds an option to the :kbd:`q` menu when `enabled `. - -.. _command-prompt: - -command-prompt -============== -An in-game DFHack terminal, where you can enter other commands. -Best used from a keybinding; by default :kbd:`Ctrl`:kbd:`Shift`:kbd:`P`. - -Usage: ``command-prompt [entry]`` - -If called with an entry, it starts with that text filled in. -Most useful for developers, who can set a keybinding to open -a laungage interpreter for lua or Ruby by starting with the -`:lua ` or `:rb ` commands. - -Otherwise somewhat similar to `gui/quickcmd`. - -.. image:: images/command-prompt.png - - -.. _hotkeys: - -hotkeys -======= -Opens an in-game screen showing which DFHack keybindings are -active in the current context. - -.. image:: images/hotkeys.png - -Type ``hotkeys`` into the DFHack console to open the screen, -or bind the command to a globally active hotkey. The default -keybinding is :kbd:`Ctrl`:kbd:`F1`. See also `hotkey-notes`. - -.. _rb: - -rb -== -Ruby language plugin, which evaluates the following arguments as a ruby string. -Best used as ``:rb [string]``, for the special parsing mode. Alias ``rb_eval``. - -.. _manipulator: - -manipulator -=========== -An in-game equivalent to the popular program Dwarf Therapist. - -To activate, open the unit screen and press :kbd:`l`. - -.. image:: images/manipulator.png - -The far left column displays the unit's Happiness (color-coded based on its -value), Name, Profession/Squad, and the right half of the screen displays each -dwarf's labor settings and skill levels (0-9 for Dabbling through Professional, -A-E for Great through Grand Master, and U-Z for Legendary through Legendary+5). - -Cells with teal backgrounds denote skills not controlled by labors, e.g. -military and social skills. - -.. image:: images/manipulator2.png - -Press :kbd:`t` to toggle between Profession and Squad view. - -.. image:: images/manipulator3.png - -Use the arrow keys or number pad to move the cursor around, holding :kbd:`Shift` to -move 10 tiles at a time. - -Press the Z-Up (:kbd:`<`) and Z-Down (:kbd:`>`) keys to move quickly between labor/skill -categories. The numpad Z-Up and Z-Down keys seek to the first or last unit -in the list. :kbd:`Backspace` seeks to the top left corner. - -Press Enter to toggle the selected labor for the selected unit, or Shift+Enter -to toggle all labors within the selected category. - -Press the :kbd:`+`:kbd:`-` keys to sort the unit list according to the currently selected -skill/labor, and press the :kbd:`*`:kbd:`/` keys to sort the unit list by Name, Profession/Squad, -Happiness, or Arrival order (using :kbd:`Tab` to select which sort method to use here). - -With a unit selected, you can press the :kbd:`v` key to view its properties (and -possibly set a custom nickname or profession) or the :kbd:`c` key to exit -Manipulator and zoom to its position within your fortress. - -The following mouse shortcuts are also available: - -* Click on a column header to sort the unit list. Left-click to sort it in one - direction (descending for happiness or labors/skills, ascending for name, - profession or squad) and right-click to sort it in the opposite direction. -* Left-click on a labor cell to toggle that labor. Right-click to move the - cursor onto that cell instead of toggling it. -* Left-click on a unit's name, profession or squad to view its properties. -* Right-click on a unit's name, profession or squad to zoom to it. - -Pressing :kbd:`Esc` normally returns to the unit screen, but :kbd:`Shift`:kbd:`Esc` would exit -directly to the main dwarf mode screen. - -.. comment - the link target "search" is reserved for the Sphinx search page -.. _search-plugin: - -search -====== -The search plugin adds search to the Stocks, Animals, Trading, Stockpile, -Noble (assignment candidates), Military (position candidates), Burrows -(unit list), Rooms, Announcements, Job List and Unit List screens. - -.. image:: images/search.png - -Searching works the same way as the search option in :guilabel:`Move to Depot`. -You will see the Search option displayed on screen with a hotkey (usually :kbd:`s`). -Pressing it lets you start typing a query and the relevant list will start -filtering automatically. - -Pressing :kbd:`Enter`, :kbd:`Esc` or the arrow keys will return you to browsing the now -filtered list, which still functions as normal. You can clear the filter -by either going back into search mode and backspacing to delete it, or -pressing the "shifted" version of the search hotkey while browsing the -list (e.g. if the hotkey is :kbd:`s`, then hitting :kbd:`Shift`:kbd:`s` will clear any -filter). - -Leaving any screen automatically clears the filter. - -In the Trade screen, the actual trade will always only act on items that -are actually visible in the list; the same effect applies to the Trade -Value numbers displayed by the screen. Because of this, the :kbd:`t` key is -blocked while search is active, so you have to reset the filters first. -Pressing :kbd:`Alt`:kbd:`C` will clear both search strings. - -In the stockpile screen the option only appears if the cursor is in the -rightmost list: - -.. image:: images/search-stockpile.png - -Note that the 'Permit XXX'/'Forbid XXX' keys conveniently operate only -on items actually shown in the rightmost list, so it is possible to select -only fat or tallow by forbidding fats, then searching for fat/tallow, and -using Permit Fats again while the list is filtered. - - -.. _nopause: - -nopause -======= -Disables pausing (both manual and automatic) with the exception of pause forced -by `reveal` ``hell``. This is nice for digging under rivers. - -.. _embark-tools: - -embark-tools -============ -A collection of embark-related tools. Usage and available tools:: - - embark-tools enable/disable tool [tool]... - -:anywhere: Allows embarking anywhere (including sites, mountain-only biomes, - and oceans). Use with caution. -:mouse: Implements mouse controls (currently in the local embark region only) -:sand: Displays an indicator when sand is present in the currently-selected - area, similar to the default clay/stone indicators. -:sticky: Maintains the selected local area while navigating the world map - -.. _automaterial: - -automaterial -============ -This makes building constructions (walls, floors, fortifications, etc) a little bit -easier by saving you from having to trawl through long lists of materials each time -you place one. - -Firstly, it moves the last used material for a given construction type to the top of -the list, if there are any left. So if you build a wall with chalk blocks, the next -time you place a wall the chalk blocks will be at the top of the list, regardless of -distance (it only does this in "grouped" mode, as individual item lists could be huge). -This should mean you can place most constructions without having to search for your -preferred material type. - -.. image:: images/automaterial-mat.png - -Pressing :kbd:`a` while highlighting any material will enable that material for "auto select" -for this construction type. You can enable multiple materials as autoselect. Now the next -time you place this type of construction, the plugin will automatically choose materials -for you from the kinds you enabled. If there is enough to satisfy the whole placement, -you won't be prompted with the material screen - the construction will be placed and you -will be back in the construction menu as if you did it manually. - -When choosing the construction placement, you will see a couple of options: - -.. image:: images/automaterial-pos.png - -Use :kbd:`a` here to temporarily disable the material autoselection, e.g. if you need -to go to the material selection screen so you can toggle some materials on or off. - -The other option (auto type selection, off by default) can be toggled on with :kbd:`t`. If you -toggle this option on, instead of returning you to the main construction menu after selecting -materials, it returns you back to this screen. If you use this along with several autoselect -enabled materials, you should be able to place complex constructions more conveniently. - -.. _buildingplan: - -buildingplan -============ -When active (via ``enable buildingplan``), this plugin adds a planning mode for -furniture placement. You can then place furniture and other buildings before -the required materials are available, and the job will be unsuspended when -the item is created. - -Very useful when combined with `workflow` - you can set a constraint -to always have one or two doors/beds/tables/chairs/etc available, and place -as many as you like. The plugins then take over and fulfill the orders, -with minimal space dedicated to stockpiles. - -.. _confirm: - -confirm -======= -Implements several confirmation dialogs for potentially destructive actions -(for example, seizing goods from traders or deleting hauling routes). - -Usage: - -:enable confirm: Enable all confirmations; alias ``confirm enable all``. - Replace with ``disable`` to disable. -:confirm help: List available confirmation dialogues. -:confirm enable option1 [option2...]: - Enable (or disable) specific confirmation dialogues. - -follow -====== -Makes the game view follow the currently highlighted unit after you exit from the -current menu or cursor mode. Handy for watching dwarves running around. Deactivated -by moving the view manually. - -.. _mousequery: - -mousequery -========== -Adds mouse controls to the DF interface, eg click-and-drag designations. - -Options: - -:plugin: enable/disable the entire plugin -:rbutton: enable/disable right mouse button -:track: enable/disable moving cursor in build and designation mode -:edge: enable/disable active edge scrolling (when on, will also enable tracking) -:live: enable/disable query view when unpaused -:delay: Set delay when edge scrolling in tracking mode. Omit amount to display current setting. - -Usage:: - - mousequery [plugin] [rbutton] [track] [edge] [live] [enable|disable] - -.. _resume: - -resume -====== -Allows automatic resumption of suspended constructions, along with colored -UI hints for construction status. - -.. _title-version: - -title-version -============= -Displays the DFHack version on DF's title screen when enabled. - -.. _trackstop: - -trackstop -========= -Adds a :kbd:`q` menu for track stops, which is completely blank by default. -This allows you to view and/or change the track stop's friction and dump -direction settings, using the keybindings from the track stop building interface. - -.. _sort-items: - -sort-items -========== -Sort the visible item list:: - - sort-items order [order...] - -Sort the item list using the given sequence of comparisons. -The ``<`` prefix for an order makes undefined values sort first. -The ``>`` prefix reverses the sort order for defined values. - -Item order examples:: - - description material wear type quality - -The orderings are defined in ``hack/lua/plugins/sort/*.lua`` - -.. _sort-units: - -sort-units -========== -Sort the visible unit list:: - - sort-units order [order...] - -Sort the unit list using the given sequence of comparisons. -The ``<`` prefix for an order makes undefined values sort first. -The ``>`` prefix reverses the sort order for defined values. - -Unit order examples:: - - name age arrival squad squad_position profession - -The orderings are defined in ``hack/lua/plugins/sort/*.lua`` - -.. _stocks: - -stocks -====== -Replaces the DF stocks screen with an improved version. - -.. _stocksettings: -.. _stockpiles: - -stocksettings -============= -Offers the following commands to save and load stockpile settings. -See `gui/stockpiles` for an in-game interface. - -:copystock: Copies the parameters of the currently highlighted stockpile to the custom - stockpile settings and switches to custom stockpile placement mode, effectively - allowing you to copy/paste stockpiles easily. - -:savestock: Saves the currently highlighted stockpile's settings to a file in your Dwarf - Fortress folder. This file can be used to copy settings between game saves or - players. eg: ``savestock food_settings.dfstock`` - -:loadstock: Loads a saved stockpile settings file and applies it to the currently selected - stockpile. eg: ``loadstock food_settings.dfstock`` - -To use savestock and loadstock, use the :kbd:`q` command to highlight a stockpile. -Then run savestock giving it a descriptive filename. Then, in a different (or -the same!) gameworld, you can highlight any stockpile with :kbd:`q` then execute the -``loadstock`` command passing it the name of that file. The settings will be -applied to that stockpile. - -Note that files are relative to the DF folder, so put your files there or in a -subfolder for easy access. Filenames should not have spaces. Generated materials, -divine metals, etc are not saved as they are different in every world. - -.. _rename: - -rename -====== -Allows renaming various things. Use `gui/rename` for an in-game interface. - -Options: - -``rename squad "name"`` - Rename squad by index to 'name'. -``rename hotkey \"name\"`` - Rename hotkey by index. This allows assigning - longer commands to the DF hotkeys. -``rename unit "nickname"`` - Rename a unit/creature highlighted in the DF user interface. -``rename unit-profession "custom profession"`` - Change proffession name of the highlighted unit/creature. -``rename building "name"`` - Set a custom name for the selected building. - The building must be one of stockpile, workshop, furnace, trap, - siege engine or an activity zone. - -.. _rendermax: - -rendermax -========= -A collection of renderer replacing/enhancing filters. For better effect try changing the -black color in palette to non totally black. See :forums:`128487` for more info. - -Options: - -:trippy: Randomizes the color of each tiles. Used for fun, or testing. -:light: Enable lighting engine. -:light reload: Reload the settings file. -:light sun |cycle: Set time to (in hours) or set it to df time cycle. -:occlusionON, occlusionOFF: Show debug occlusion info. -:disable: Disable any filter that is enabled. - -An image showing lava and dragon breath. Not pictured here: sunlight, shining items/plants, -materials that color the light etc... - -.. image:: images/rendermax.png - - -=========================== -Job and Fortress management -=========================== - -.. contents:: - :local: - -.. _autolabor: - -autolabor -========= -Automatically manage dwarf labors to efficiently complete jobs. -Autolabor tries to keep as many dwarves as possible busy but -also tries to have dwarves specialize in specific skills. - -The key is that, for almost all labors, once a dwarf begins a job it will finish that -job even if the associated labor is removed. Autolabor therefore frequently checks -which dwarf or dwarves should take new jobs for that labor, and sets labors accordingly. -Labors with equiptment (mining, hunting, and woodcutting), which are abandoned -if labors change mid-job, are handled slightly differently to minimise churn. - -.. warning:: - - *autolabor will override any manual changes you make to labors while - it is enabled, including through other tools such as Dwarf Therapist* - -Simple usage: - -:enable autolabor: Enables the plugin with default settings. (Persistent per fortress) -:disable autolabor: Disables the plugin. - -Anything beyond this is optional - autolabor works well on the default settings. - -By default, each labor is assigned to between 1 and 200 dwarves (2-200 for mining). -By default 33% of the workforce become haulers, who handle all hauling jobs as well -as cleaning, pulling levers, recovering wounded, removing constructions, and filling ponds. -Other jobs are automatically assigned as described above. Each of these settings can be adjusted. - -Jobs are rarely assigned to nobles with responsibilities for meeting diplomats or merchants, -never to the chief medical dwarf, and less often to the bookeeper and manager. - -Hunting is never assigned without a butchery, and fishing is never assigned without a fishery. - -For each labor a preference order is calculated based on skill, biased against masters of other -trades and excluding those who can't do the job. The labor is then added to the best -dwarves for that labor. We assign at least the minimum number of dwarfs, in order of preference, -and then assign additional dwarfs that meet any of these conditions: - -* The dwarf is idle and there are no idle dwarves assigned to this labor -* The dwarf has non-zero skill associated with the labor -* The labor is mining, hunting, or woodcutting and the dwarf currently has it enabled. - -We stop assigning dwarfs when we reach the maximum allowed. - -Advanced usage: - -:autolabor []: - Set number of dwarves assigned to a labor. -:autolabor haulers: Set a labor to be handled by hauler dwarves. -:autolabor disable: Turn off autolabor for a specific labor. -:autolabor reset: Return a labor to the default handling. -:autolabor reset-all: Return all labors to the default handling. -:autolabor list: List current status of all labors. -:autolabor status: Show basic status information. - -See `autolabor-artisans` for a differently-tuned setup. - -Examples: - -``autolabor MINE`` - Keep at least 5 dwarves with mining enabled. -``autolabor CUT_GEM 1 1`` - Keep exactly 1 dwarf with gemcutting enabled. -``autolabor COOK 1 1 3`` - Keep 1 dwarf with cooking enabled, selected only from the top 3. -``autolabor FEED_WATER_CIVILIANS haulers`` - Have haulers feed and water wounded dwarves. -``autolabor CUTWOOD disable`` - Turn off autolabor for wood cutting. - -.. _autohauler: - -autohauler -========== -Autohauler is an autolabor fork. - -Rather than the all-of-the-above means of autolabor, autohauler will instead -only manage hauling labors and leave skilled labors entirely to the user, who -will probably use Dwarf Therapist to do so. - -Idle dwarves will be assigned the hauling labors; everyone else (including -those currently hauling) will have the hauling labors removed. This is to -encourage every dwarf to do their assigned skilled labors whenever possible, -but resort to hauling when those jobs are not available. This also implies -that the user will have a very tight skill assignment, with most skilled -labors only being assigned to just one dwarf, no dwarf having more than two -active skilled labors, and almost every non-military dwarf having at least -one skilled labor assigned. - -Autohauler allows skills to be flagged as to prevent hauling labors from -being assigned when the skill is present. By default this is the unused -ALCHEMIST labor but can be changed by the user. - - -.. _job: - -job -=== -Command for general job query and manipulation. - -Options: - -*no extra options* - Print details of the current job. The job can be selected - in a workshop, or the unit/jobs screen. -**list** - Print details of all jobs in the selected workshop. -**item-material ** - Replace the exact material id in the job item. -**item-type ** - Replace the exact item type id in the job item. - -job-material -============ -Alter the material of the selected job. Similar to ``job item-material ...`` - -Invoked as:: - - job-material - -Intended to be used as a keybinding: - -* In :kbd:`q` mode, when a job is highlighted within a workshop or furnace, - changes the material of the job. Only inorganic materials can be used - in this mode. -* In :kbd:`b` mode, during selection of building components positions the cursor - over the first available choice with the matching material. - -job-duplicate -============= -In :kbd:`q` mode, when a job is highlighted within a workshop or furnace -building, calling ``job-duplicate`` instantly duplicates the job. - -.. _autogems: - -autogems -======== -Creates a new Workshop Order setting, automatically cutting rough gems -when `enabled `. - -.. _stockflow: - -stockflow -========= -Allows the fortress bookkeeper to queue jobs through the manager, -based on space or items available in stockpiles. - -Inspired by `workflow`. - -Usage: - -``stockflow enable`` - Enable the plugin. -``stockflow disable`` - Disable the plugin. -``stockflow fast`` - Enable the plugin in fast mode. -``stockflow list`` - List any work order settings for your stockpiles. -``stockflow status`` - Display whether the plugin is enabled. - -While enabled, the :kbd:`q` menu of each stockpile will have two new options: - -* :kbd:`j`: Select a job to order, from an interface like the manager's screen. -* :kbd:`J`: Cycle between several options for how many such jobs to order. - -Whenever the bookkeeper updates stockpile records, new work orders will -be placed on the manager's queue for each such selection, reduced by the -number of identical orders already in the queue. - -In fast mode, new work orders will be enqueued once per day, instead of -waiting for the bookkeeper. - -.. _workflow: - -workflow -======== -Manage control of repeat jobs. `gui/workflow` provides a simple -front-end integrated in the game UI. - -Usage: - -``workflow enable [option...], workflow disable [option...]`` - If no options are specified, enables or disables the plugin. - Otherwise, enables or disables any of the following options: - - - drybuckets: Automatically empty abandoned water buckets. - - auto-melt: Resume melt jobs when there are objects to melt. -``workflow jobs`` - List workflow-controlled jobs (if in a workshop, filtered by it). -``workflow list`` - List active constraints, and their job counts. -``workflow list-commands`` - List active constraints as workflow commands that re-create them; - this list can be copied to a file, and then reloaded using the - ``script`` built-in command. -``workflow count [cnt-gap]`` - Set a constraint, counting every stack as 1 item. -``workflow amount [cnt-gap]`` - Set a constraint, counting all items within stacks. -``workflow unlimit `` - Delete a constraint. -``workflow unlimit-all`` - Delete all constraints. - -Function --------- -When the plugin is enabled, it protects all repeat jobs from removal. -If they do disappear due to any cause, they are immediately re-added to their -workshop and suspended. - -In addition, when any constraints on item amounts are set, repeat jobs that -produce that kind of item are automatically suspended and resumed as the item -amount goes above or below the limit. The gap specifies how much below the limit -the amount has to drop before jobs are resumed; this is intended to reduce -the frequency of jobs being toggled. - -Constraint format ------------------ -The constraint spec consists of 4 parts, separated with ``/`` characters:: - - ITEM[:SUBTYPE]/[GENERIC_MAT,...]/[SPECIFIC_MAT:...]/[LOCAL,] - -The first part is mandatory and specifies the item type and subtype, -using the raw tokens for items (the same syntax used custom reaction inputs). -For more information, see :wiki:`this wiki page `. - -The subsequent parts are optional: - -- A generic material spec constrains the item material to one of - the hard-coded generic classes, which currently include:: - - PLANT WOOD CLOTH SILK LEATHER BONE SHELL SOAP TOOTH HORN PEARL YARN - METAL STONE SAND GLASS CLAY MILK - -- A specific material spec chooses the material exactly, using the - raw syntax for reaction input materials, e.g. ``INORGANIC:IRON``, - although for convenience it also allows just ``IRON``, or ``ACACIA:WOOD`` etc. - See the link above for more details on the unabbreviated raw syntax. - -- A comma-separated list of miscellaneous flags, which currently can - be used to ignore imported items or items below a certain quality. - -Constraint examples -------------------- -Keep metal bolts within 900-1000, and wood/bone within 150-200:: - - workflow amount AMMO:ITEM_AMMO_BOLTS/METAL 1000 100 - workflow amount AMMO:ITEM_AMMO_BOLTS/WOOD,BONE 200 50 - -Keep the number of prepared food & drink stacks between 90 and 120:: - - workflow count FOOD 120 30 - workflow count DRINK 120 30 - -Make sure there are always 25-30 empty bins/barrels/bags:: - - workflow count BIN 30 - workflow count BARREL 30 - workflow count BOX/CLOTH,SILK,YARN 30 - -Make sure there are always 15-20 coal and 25-30 copper bars:: - - workflow count BAR//COAL 20 - workflow count BAR//COPPER 30 - -Produce 15-20 gold crafts:: - - workflow count CRAFTS//GOLD 20 - -Collect 15-20 sand bags and clay boulders:: - - workflow count POWDER_MISC/SAND 20 - workflow count BOULDER/CLAY 20 - -Make sure there are always 80-100 units of dimple dye:: - - workflow amount POWDER_MISC//MUSHROOM_CUP_DIMPLE:MILL 100 20 - -.. note:: - - In order for this to work, you have to set the material of the PLANT input - on the Mill Plants job to MUSHROOM_CUP_DIMPLE using the `job item-material ` - command. Otherwise the plugin won't be able to deduce the output material. - -Maintain 10-100 locally-made crafts of exceptional quality:: - - workflow count CRAFTS///LOCAL,EXCEPTIONAL 100 90 - -.. _fix-job-postings: - -fix-job-postings ----------------- -This command fixes crashes caused by previous versions of workflow, mostly in -DFHack 0.40.24-r4, and should be run automatically when loading a world (but can -also be run manually if desired). - -.. _clean: - -clean -===== -Cleans all the splatter that get scattered all over the map, items and -creatures. In an old fortress, this can significantly reduce FPS lag. It can -also spoil your !!FUN!!, so think before you use it. - -Options: - -:map: Clean the map tiles. By default, it leaves mud and snow alone. -:units: Clean the creatures. Will also clean hostiles. -:items: Clean all the items. Even a poisoned blade. - -Extra options for ``map``: - -:mud: Remove mud in addition to the normal stuff. -:snow: Also remove snow coverings. - -spotclean -========= -Works like ``clean map snow mud``, but only for the tile under the cursor. Ideal -if you want to keep that bloody entrance ``clean map`` would clean up. - -.. _autodump: - -autodump -======== -This plugin adds an option to the :kbd:`q` menu for stckpiles when `enabled `. -When autodump is enabled for a stockpile, any items placed in the stockpile will -automatically be designated to be dumped. - -Alternatively, you can use it to quickly move all items designated to be dumped. -Items are instantly moved to the cursor position, the dump flag is unset, -and the forbid flag is set, as if it had been dumped normally. -Be aware that any active dump item tasks still point at the item. - -Cursor must be placed on a floor tile so the items can be dumped there. - -Options: - -:destroy: Destroy instead of dumping. Doesn't require a cursor. - If called again before the game is resumed, cancels destroy. -:destroy-here: As ``destroy``, but only the selected item in the :kbd:`k` list, - or inside a container. - Alias ``autodump-destroy-here``, for keybindings. -:visible: Only process items that are not hidden. -:hidden: Only process hidden items. -:forbidden: Only process forbidden items (default: only unforbidden). - - -cleanowned -========== -Confiscates items owned by dwarfs. By default, owned food on the floor -and rotten items are confistacted and dumped. - -Options: - -:all: confiscate all owned items -:scattered: confiscated and dump all items scattered on the floor -:x: confiscate/dump items with wear level 'x' and more -:X: confiscate/dump items with wear level 'X' and more -:dryrun: a dry run. combine with other options to see what will happen - without it actually happening. - -Example: - -``cleanowned scattered X`` - This will confiscate rotten and dropped food, garbage on the floors and any - worn items with 'X' damage and above. - - -.. _dwarfmonitor: - -dwarfmonitor -============ -Records dwarf activity to measure fort efficiency. - -Options: - -:enable : Start monitoring ``mode``. ``mode`` can be "work", "misery", - "weather", or "all". This will enable all corresponding widgets, - if applicable. -:disable : Stop monitoring ``mode``, and disable corresponding widgets, if applicable. -:stats: Show statistics summary -:prefs: Show dwarf preferences summary -:reload: Reload configuration file (``dfhack-config/dwarfmonitor.json``) - -Widget configuration: - -The following types of widgets (defined in :file:`hack/lua/plugins/dwarfmonitor.lua`) -can be displayed on the main fortress mode screen: - -:date: Show the in-game date -:misery: Show overall happiness levels of all dwarves -:weather: Show current weather (rain/snow) -:cursor: Show the current mouse cursor position - -The file :file:`dfhack-config/dwarfmonitor.json` can be edited to control the -positions and settings of all widgets displayed. This file should contain a -JSON object with the key ``widgets`` containing an array of objects - see the -included file in the ``dfhack-config`` folder for an example:: - - { - "widgets": [ - { - "type": "widget type (weather, misery, etc.)", - "x": X coordinate, - "y": Y coordinate - <...additional options...> - } - ] - } - -X and Y coordinates begin at zero (in the upper left corner of the screen). -Negative coordinates will be treated as distances from the lower right corner, -beginning at 1 - e.g. an x coordinate of 0 is the leftmost column, while an x -coordinate of 1 is the rightmost column. - -By default, the x and y coordinates given correspond to the leftmost tile of -the widget. Including an ``anchor`` option set to ``right`` will cause the -rightmost tile of the widget to be located at this position instead. - -Some widgets support additional options: - -* ``date`` widget: - - * ``format``: specifies the format of the date. The following characters - are replaced (all others, such as punctuation, are not modified) - - * ``Y`` or ``y``: The current year - * ``M``: The current month, zero-padded if necessary - * ``m``: The current month, *not* zero-padded - * ``D``: The current day, zero-padded if necessary - * ``d``: The current day, *not* zero-padded - - The default date format is ``Y-M-D``, per the ISO8601_ standard. - - .. _ISO8601: https://en.wikipedia.org/wiki/ISO_8601 - -* ``cursor`` widget: - - * ``format``: Specifies the format. ``X``, ``x``, ``Y``, and ``y`` are - replaced with the corresponding cursor cordinates, while all other - characters are unmodified. - * ``show_invalid``: If set to ``true``, the mouse coordinates will both be - displayed as ``-1`` when the cursor is outside of the DF window; otherwise, - nothing will be displayed. - -.. _workNow: - -workNow -======= -Force all dwarves to look for a job immediately, or as soon as the game is unpaused. - -.. _seedwatch: - -seedwatch -========= -Watches the numbers of seeds available and enables/disables seed and plant cooking. - -Each plant type can be assigned a limit. If their number falls below that limit, -the plants and seeds of that type will be excluded from cookery. -If the number rises above the limit + 20, then cooking will be allowed. - -The plugin needs a fortress to be loaded and will deactivate automatically otherwise. -You have to reactivate with 'seedwatch start' after you load the game. - -Options: - -:all: Adds all plants from the abbreviation list to the watch list. -:start: Start watching. -:stop: Stop watching. -:info: Display whether seedwatch is watching, and the watch list. -:clear: Clears the watch list. - -Examples: - -``seedwatch MUSHROOM_HELMET_PLUMP 30`` - add ``MUSHROOM_HELMET_PLUMP`` to the watch list, limit = 30 -``seedwatch MUSHROOM_HELMET_PLUMP`` - removes ``MUSHROOM_HELMET_PLUMP`` from the watch list. -``seedwatch all 30`` - adds all plants from the abbreviation list to the watch list, the limit being 30. - -.. _zone: - -zone -==== -Helps a bit with managing activity zones (pens, pastures and pits) and cages. - -Options: - -:set: Set zone or cage under cursor as default for future assigns. -:assign: Assign unit(s) to the pen or pit marked with the 'set' command. - If no filters are set a unit must be selected in the in-game ui. - Can also be followed by a valid zone id which will be set - instead. -:unassign: Unassign selected creature from it's zone. -:nick: Mass-assign nicknames, must be followed by the name you want - to set. -:remnick: Mass-remove nicknames. -:tocages: Assign unit(s) to cages inside a pasture. -:uinfo: Print info about unit(s). If no filters are set a unit must - be selected in the in-game ui. -:zinfo: Print info about zone(s). If no filters are set zones under - the cursor are listed. -:verbose: Print some more info. -:filters: Print list of valid filter options. -:examples: Print some usage examples. -:not: Negates the next filter keyword. - -Filters: - -:all: Process all units (to be used with additional filters). -:count: Must be followed by a number. Process only n units (to be used - with additional filters). -:unassigned: Not assigned to zone, chain or built cage. -:minage: Minimum age. Must be followed by number. -:maxage: Maximum age. Must be followed by number. -:race: Must be followed by a race RAW ID (e.g. BIRD_TURKEY, ALPACA, - etc). Negatable. -:caged: In a built cage. Negatable. -:own: From own civilization. Negatable. -:merchant: Is a merchant / belongs to a merchant. Should only be used for - pitting, not for stealing animals (slaughter should work). -:war: Trained war creature. Negatable. -:hunting: Trained hunting creature. Negatable. -:tamed: Creature is tame. Negatable. -:trained: Creature is trained. Finds war/hunting creatures as well as - creatures who have a training level greater than 'domesticated'. - If you want to specifically search for war/hunting creatures use - 'war' or 'hunting' Negatable. -:trainablewar: Creature can be trained for war (and is not already trained for - war/hunt). Negatable. -:trainablehunt: Creature can be trained for hunting (and is not already trained - for war/hunt). Negatable. -:male: Creature is male. Negatable. -:female: Creature is female. Negatable. -:egglayer: Race lays eggs. Negatable. -:grazer: Race is a grazer. Negatable. -:milkable: Race is milkable. Negatable. - -Usage with single units ------------------------ -One convenient way to use the zone tool is to bind the command 'zone assign' to -a hotkey, maybe also the command 'zone set'. Place the in-game cursor over -a pen/pasture or pit, use 'zone set' to mark it. Then you can select units -on the map (in 'v' or 'k' mode), in the unit list or from inside cages -and use 'zone assign' to assign them to their new home. Allows pitting your -own dwarves, by the way. - -Usage with filters ------------------- -All filters can be used together with the 'assign' command. - -Restrictions: It's not possible to assign units who are inside built cages -or chained because in most cases that won't be desirable anyways. -It's not possible to cage owned pets because in that case the owner -uncages them after a while which results in infinite hauling back and forth. - -Usually you should always use the filter 'own' (which implies tame) unless you -want to use the zone tool for pitting hostiles. 'own' ignores own dwarves unless -you specify 'race DWARF' (so it's safe to use 'assign all own' to one big -pasture if you want to have all your animals at the same place). 'egglayer' and -'milkable' should be used together with 'female' unless you have a mod with -egg-laying male elves who give milk or whatever. Merchants and their animals are -ignored unless you specify 'merchant' (pitting them should be no problem, -but stealing and pasturing their animals is not a good idea since currently they -are not properly added to your own stocks; slaughtering them should work). - -Most filters can be negated (e.g. 'not grazer' -> race is not a grazer). - -Mass-renaming -------------- -Using the 'nick' command you can set the same nickname for multiple units. -If used without 'assign', 'all' or 'count' it will rename all units in the -current default target zone. Combined with 'assign', 'all' or 'count' (and -further optional filters) it will rename units matching the filter conditions. - -Cage zones ----------- -Using the 'tocages' command you can assign units to a set of cages, for example -a room next to your butcher shop(s). They will be spread evenly among available -cages to optimize hauling to and butchering from them. For this to work you need -to build cages and then place one pen/pasture activity zone above them, covering -all cages you want to use. Then use 'zone set' (like with 'assign') and use -'zone tocages filter1 filter2 ...'. 'tocages' overwrites 'assign' because it -would make no sense, but can be used together with 'nick' or 'remnick' and all -the usual filters. - -Examples --------- -``zone assign all own ALPACA minage 3 maxage 10`` - Assign all own alpacas who are between 3 and 10 years old to the selected - pasture. -``zone assign all own caged grazer nick ineedgrass`` - Assign all own grazers who are sitting in cages on stockpiles (e.g. after - buying them from merchants) to the selected pasture and give them - the nickname 'ineedgrass'. -``zone assign all own not grazer not race CAT`` - Assign all own animals who are not grazers, excluding cats. -``zone assign count 5 own female milkable`` - Assign up to 5 own female milkable creatures to the selected pasture. -``zone assign all own race DWARF maxage 2`` - Throw all useless kids into a pit :) -``zone nick donttouchme`` - Nicknames all units in the current default zone or cage to 'donttouchme'. - Mostly intended to be used for special pastures or cages which are not marked - as rooms you want to protect from autobutcher. -``zone tocages count 50 own tame male not grazer`` - Stuff up to 50 owned tame male animals who are not grazers into cages built - on the current default zone. - -autonestbox -=========== -Assigns unpastured female egg-layers to nestbox zones. Requires that you create -pen/pasture zones above nestboxes. If the pen is bigger than 1x1 the nestbox -must be in the top left corner. Only 1 unit will be assigned per pen, regardless -of the size. The age of the units is currently not checked, most birds grow up -quite fast. Egglayers who are also grazers will be ignored, since confining them -to a 1x1 pasture is not a good idea. Only tame and domesticated own units are -processed since pasturing half-trained wild egglayers could destroy your neat -nestbox zones when they revert to wild. When called without options autonestbox -will instantly run once. - -Options: - -:start: Start running every X frames (df simulation ticks). - Default: X=6000, which would be every 60 seconds at 100fps. -:stop: Stop running automatically. -:sleep: Must be followed by number X. Changes the timer to sleep X - frames between runs. - -.. _autobutcher: - -autobutcher -=========== -Assigns lifestock for slaughter once it reaches a specific count. Requires that -you add the target race(s) to a watch list. Only tame units will be processed. - -Units will be ignored if they are: - -* Nicknamed (for custom protection; you can use the `rename` ``unit`` tool - individually, or `zone` ``nick`` for groups) -* Caged, if and only if the cage is defined as a room (to protect zoos) -* Trained for war or hunting - -Creatures who will not reproduce (because they're not interested in the -opposite sex or have been gelded) will be butchered before those who will. -Older adults and younger children will be butchered first if the population -is above the target (default 1 male, 5 female kids and adults). Note that -you may need to set a target above 1 to have a reliable breeding population -due to asexuality etc. See `fix-ster` if this is a problem. - -Options: - -:example: Print some usage examples. -:start: Start running every X frames (df simulation ticks). - Default: X=6000, which would be every 60 seconds at 100fps. -:stop: Stop running automatically. -:sleep : Changes the timer to sleep X frames between runs. -:watch R: Start watching a race. R can be a valid race RAW id (ALPACA, - BIRD_TURKEY, etc) or a list of ids seperated by spaces or - the keyword 'all' which affects all races on your current - watchlist. -:unwatch R: Stop watching race(s). The current target settings will be - remembered. R can be a list of ids or the keyword 'all'. -:forget R: Stop watching race(s) and forget it's/their target settings. - R can be a list of ids or the keyword 'all'. -:autowatch: Automatically adds all new races (animals you buy from merchants, - tame yourself or get from migrants) to the watch list using - default target count. -:noautowatch: Stop auto-adding new races to the watchlist. -:list: Print the current status and watchlist. -:list_export: Print the commands needed to set up status and watchlist, - which can be used to import them to another save (see notes). -:target : - Set target count for specified race(s). The first four arguments - are the number of female and male kids, and female and male adults. - R can be a list of spceies ids, or the keyword ``all`` or ``new``. - ``R = 'all'``: change target count for all races on watchlist - and set the new default for the future. ``R = 'new'``: don't touch - current settings on the watchlist, only set the new default - for future entries. -:list_export: Print the commands required to rebuild your current settings. - -.. note:: - - Settings and watchlist are stored in the savegame, so that you can have - different settings for each save. If you want to copy your watchlist to - another savegame you must export the commands required to recreate your settings. - - To export, open an external terminal in the DF directory, and run - ``dfhack-run autobutcher list_export > filename.txt``. To import, load your - new save and run ``script filename.txt`` in the DFHack terminal. - - -Examples: - -You want to keep max 7 kids (4 female, 3 male) and max 3 adults (2 female, -1 male) of the race alpaca. Once the kids grow up the oldest adults will get -slaughtered. Excess kids will get slaughtered starting with the youngest -to allow that the older ones grow into adults. Any unnamed cats will -be slaughtered as soon as possible. :: - - autobutcher target 4 3 2 1 ALPACA BIRD_TURKEY - autobutcher target 0 0 0 0 CAT - autobutcher watch ALPACA BIRD_TURKEY CAT - autobutcher start - -Automatically put all new races onto the watchlist and mark unnamed tame units -for slaughter as soon as they arrive in your fort. Settings already made -for specific races will be left untouched. :: - - autobutcher target 0 0 0 0 new - autobutcher autowatch - autobutcher start - -Stop watching the races alpaca and cat, but remember the target count -settings so that you can use 'unwatch' without the need to enter the -values again. Note: 'autobutcher unwatch all' works, but only makes sense -if you want to keep the plugin running with the 'autowatch' feature or manually -add some new races with 'watch'. If you simply want to stop it completely use -'autobutcher stop' instead. :: - - autobutcher unwatch ALPACA CAT - -.. _autochop: - -autochop -======== -Automatically manage tree cutting designation to keep available logs withing given -quotas. - -Open the dashboard by running:: - - getplants autochop - -The plugin must be activated (with ``c``) before it can be used. You can then set logging quotas -and restrict designations to specific burrows (with 'Enter') if desired. The plugin's activity -cycle runs once every in game day. - -If you add ``enable getplants`` to your dfhack.init there will be a hotkey to -open the dashboard from the chop designation menu. - - -================ -Map modification -================ - -.. contents:: - :local: - -.. _3dveins: - -3dveins -======= -Removes all existing veins from the map and generates new ones using -3D Perlin noise, in order to produce a layout that smoothly flows between -Z levels. The vein distribution is based on the world seed, so running -the command for the second time should produce no change. It is best to -run it just once immediately after embark. - -This command is intended as only a cosmetic change, so it takes -care to exactly preserve the mineral counts reported by `prospect` ``all``. -The amounts of different layer stones may slightly change in some cases -if vein mass shifts between Z layers. - -The only undo option is to restore your save from backup. - -.. _alltraffic: - -alltraffic -========== -Set traffic designations for every single tile of the map - useful for resetting -traffic designations. See also `filltraffic`, `restrictice`, and `restrictliquids`. - -Options: - -:H: High Traffic -:N: Normal Traffic -:L: Low Traffic -:R: Restricted Traffic - -.. _burrow: - -burrow -====== -Miscellaneous burrow control. Allows manipulating burrows and automated burrow -expansion while digging. - -Options: - -:enable feature ...: - Enable features of the plugin. -:disable feature ...: - Disable features of the plugin. -:clear-unit burrow burrow ...: - Remove all units from the burrows. -:clear-tiles burrow burrow ...: - Remove all tiles from the burrows. -:set-units target-burrow src-burrow ...: - Clear target, and adds units from source burrows. -:add-units target-burrow src-burrow ...: - Add units from the source burrows to the target. -:remove-units target-burrow src-burrow ...: - Remove units in source burrows from the target. -:set-tiles target-burrow src-burrow ...: - Clear target and adds tiles from the source burrows. -:add-tiles target-burrow src-burrow ...: - Add tiles from the source burrows to the target. -:remove-tiles target-burrow src-burrow ...: - Remove tiles in source burrows from the target. - - For these three options, in place of a source burrow it is - possible to use one of the following keywords: ABOVE_GROUND, - SUBTERRANEAN, INSIDE, OUTSIDE, LIGHT, DARK, HIDDEN, REVEALED - -Features: - -:auto-grow: When a wall inside a burrow with a name ending in '+' is dug - out, the burrow is extended to newly-revealed adjacent walls. - This final '+' may be omitted in burrow name args of commands above. - Digging 1-wide corridors with the miner inside the burrow is SLOW. - - -.. _changelayer: - -changelayer -=========== -Changes material of the geology layer under cursor to the specified inorganic -RAW material. Can have impact on all surrounding regions, not only your embark! -By default changing stone to soil and vice versa is not allowed. By default -changes only the layer at the cursor position. Note that one layer can stretch -across lots of z levels. By default changes only the geology which is linked -to the biome under the cursor. That geology might be linked to other biomes -as well, though. Mineral veins and gem clusters will stay on the map. Use -`changevein` for them. - -tl;dr: You will end up with changing quite big areas in one go, especially if -you use it in lower z levels. Use with care. - -Options: - -:all_biomes: Change selected layer for all biomes on your map. - Result may be undesirable since the same layer can AND WILL - be on different z-levels for different biomes. Use the tool - 'probe' to get an idea how layers and biomes are distributed - on your map. -:all_layers: Change all layers on your map (only for the selected biome - unless 'all_biomes' is added). - Candy mountain, anyone? Will make your map quite boring, - but tidy. -:force: Allow changing stone to soil and vice versa. !!THIS CAN HAVE - WEIRD EFFECTS, USE WITH CARE!! - Note that soil will not be magically replaced with stone. - You will, however, get a stone floor after digging so it - will allow the floor to be engraved. - Note that stone will not be magically replaced with soil. - You will, however, get a soil floor after digging so it - could be helpful for creating farm plots on maps with no - soil. -:verbose: Give some details about what is being changed. -:trouble: Give some advice about known problems. - -Examples: - -``changelayer GRANITE`` - Convert layer at cursor position into granite. -``changelayer SILTY_CLAY force`` - Convert layer at cursor position into clay even if it's stone. -``changelayer MARBLE all_biomes all_layers`` - Convert all layers of all biomes which are not soil into marble. - -.. note:: - - * If you use changelayer and nothing happens, try to pause/unpause the game - for a while and try to move the cursor to another tile. Then try again. - If that doesn't help try temporarily changing some other layer, undo your - changes and try again for the layer you want to change. Saving - and reloading your map might also help. - * You should be fine if you only change single layers without the use - of 'force'. Still it's advisable to save your game before messing with - the map. - * When you force changelayer to convert soil to stone you might experience - weird stuff (flashing tiles, tiles changed all over place etc). - Try reverting the changes manually or even better use an older savegame. - You did save your game, right? - -.. _changevein: - -changevein -========== -Changes material of the vein under cursor to the specified inorganic RAW -material. Only affects tiles within the current 16x16 block - for veins and -large clusters, you will need to use this command multiple times. - -Example: - -``changevein NATIVE_PLATINUM`` - Convert vein at cursor position into platinum ore. - -.. _changeitem: - -changeitem -========== -Allows changing item material and base quality. By default the item currently -selected in the UI will be changed (you can select items in the 'k' list -or inside containers/inventory). By default change is only allowed if materials -is of the same subtype (for example wood<->wood, stone<->stone etc). But since -some transformations work pretty well and may be desired you can override this -with 'force'. Note that some attributes will not be touched, possibly resulting -in weirdness. To get an idea how the RAW id should look like, check some items -with 'info'. Using 'force' might create items which are not touched by -crafters/haulers. - -Options: - -:info: Don't change anything, print some info instead. -:here: Change all items at the cursor position. Requires in-game cursor. -:material, m: Change material. Must be followed by valid material RAW id. -:quality, q: Change base quality. Must be followed by number (0-5). -:force: Ignore subtypes, force change to new material. - -Examples: - -``changeitem m INORGANIC:GRANITE here`` - Change material of all items under the cursor to granite. -``changeitem q 5`` - Change currently selected item to masterpiece quality. - -.. _cleanconst: - -cleanconst -========== -Cleans up construction materials. - -This utility alters all constructions on the map so that they spawn their -building component when they are disassembled, allowing their actual -build items to be safely deleted. This can improve FPS in extreme situations. - -.. _deramp: - -deramp -====== -Removes all ramps designated for removal from the map. This is useful for -replicating the old channel digging designation. It also removes any and -all 'down ramps' that can remain after a cave-in (you don't have to designate -anything for that to happen). - -.. _dig: - -dig -=== -This plugin makes many automated or complicated dig patterns easy. - -Basic commands: - -:digv: Designate all of the selected vein for digging. -:digvx: Also cross z-levels, digging stairs as needed. Alias for ``digv x``. -:digl: Like ``digv``, for layer stone. Also supports an ``undo`` option - to remove designations, for if you accidentally set 50 levels at once. -:diglx: Also cross z-levels, digging stairs as needed. Alias for ``digl x``. - -.. _digexp: - -digexp -====== -This command is for :wiki:`exploratory mining `. - -There are two variables that can be set: pattern and filter. - -Patterns: - -:diag5: diagonals separated by 5 tiles -:diag5r: diag5 rotated 90 degrees -:ladder: A 'ladder' pattern -:ladderr: ladder rotated 90 degrees -:clear: Just remove all dig designations -:cross: A cross, exactly in the middle of the map. - -Filters: - -:all: designate whole z-level -:hidden: designate only hidden tiles of z-level (default) -:designated: Take current designation and apply pattern to it. - -After you have a pattern set, you can use ``expdig`` to apply it again. - -Examples: - -``expdig diag5 hidden`` - Designate the diagonal 5 patter over all hidden tiles -``expdig`` - Apply last used pattern and filter -``expdig ladder designated`` - Take current designations and replace them with the ladder pattern - -.. _digcircle: - -digcircle -========= -A command for easy designation of filled and hollow circles. -It has several types of options. - -Shape: - -:hollow: Set the circle to hollow (default) -:filled: Set the circle to filled -:#: Diameter in tiles (default = 0, does nothing) - -Action: - -:set: Set designation (default) -:unset: Unset current designation -:invert: Invert designations already present - -Designation types: - -:dig: Normal digging designation (default) -:ramp: Ramp digging -:ustair: Staircase up -:dstair: Staircase down -:xstair: Staircase up/down -:chan: Dig channel - -After you have set the options, the command called with no options -repeats with the last selected parameters. - -Examples: - -``digcircle filled 3`` - Dig a filled circle with diameter = 3. -``digcircle`` - Do it again. - -.. _digtype: - -digtype -======= -For every tile on the map of the same vein type as the selected tile, -this command designates it to have the same designation as the -selected tile. If the selected tile has no designation, they will be -dig designated. -If an argument is given, the designation of the selected tile is -ignored, and all appropriate tiles are set to the specified -designation. - -Options: - -:dig: -:channel: -:ramp: -:updown: up/down stairs -:up: up stairs -:down: down stairs -:clear: clear designation - -.. _digFlood: - -digFlood -======== -Automatically digs out specified veins as they are discovered. It runs once -every time a dwarf finishes a dig job. It will only dig out appropriate tiles -that are adjacent to the finished dig job. To add a vein type, use ``digFlood 1 [type]``. -This will also enable the plugin. To remove a vein type, use ``digFlood 0 [type] 1`` -to disable, then remove, then re-enable. - -Usage: - -:help digflood: detailed help message -:digFlood 0: disable the plugin -:digFlood 1: enable the plugin -:digFlood 0 MICROCLINE COAL_BITUMINOUS 1: - disable plugin, remove microcline and bituminous coal from monitoring, then re-enable the plugin -:digFlood CLEAR: remove all inorganics from monitoring -:digFlood digAll1: ignore the monitor list and dig any vein -:digFlood digAll0: disable digAll mode - -.. _filltraffic: - -filltraffic -=========== -Set traffic designations using flood-fill starting at the cursor. -See also `alltraffic`, `restrictice`, and `restrictliquids`. Options: - -:H: High Traffic -:N: Normal Traffic -:L: Low Traffic -:R: Restricted Traffic -:X: Fill across z-levels. -:B: Include buildings and stockpiles. -:P: Include empty space. - -Example: - -``filltraffic H`` - When used in a room with doors, it will set traffic to HIGH in just that room. - -.. _fortplan: - -fortplan -======== -Usage: ``fortplan [filename]`` - -Designates furniture for building according to a ``.csv`` file with -quickfort-style syntax. Companion to `digfort`. - -The first line of the file must contain the following:: - - #build start(X; Y; ) - -...where X and Y are the offset from the top-left corner of the file's area -where the in-game cursor should be located, and ```` -is an optional description of where that is. You may also leave a description -of the contents of the file itself following the closing parenthesis on the -same line. - -The syntax of the file itself is similar to `digfort` or :forums:`quickfort <35931>`. -At present, only buildings constructed of an item with the same name as the building -are supported. All other characters are ignored. For example:: - - `,`,d,`,` - `,f,`,t,` - `,s,b,c,` - -This section of a file would designate for construction a door and some -furniture inside a bedroom: specifically, clockwise from top left, a cabinet, -a table, a chair, a bed, and a statue. - -All of the building designation uses `buildingplan`, so you do not need to -have the items available to construct all the buildings when you run -fortplan with the .csv file. - -.. _getplants: - -getplants -========= -This tool allows plant gathering and tree cutting by RAW ID. Specify the types -of trees to cut down and/or shrubs to gather by their plant names, separated -by spaces. - -Options: - -:-t: Select trees only (exclude shrubs) -:-s: Select shrubs only (exclude trees) -:-c: Clear designations instead of setting them -:-x: Apply selected action to all plants except those specified (invert - selection) -:-a: Select every type of plant (obeys ``-t``/``-s``) - -Specifying both ``-t`` and ``-s`` will have no effect. If no plant IDs are specified, -all valid plant IDs will be listed. - -.. _infiniteSky: - -infiniteSky -=========== -Automatically allocates new z-levels of sky at the top of the map as you build up, -or on request allocates many levels all at once. - -Usage: - -``infiniteSky n`` - Raise the sky by n z-levels. -``infiniteSky enable/disable`` - Enables/disables monitoring of constructions. If you build anything in the second to highest z-level, it will allocate one more sky level. This is so you can continue to build stairs upward. - -:issue:`Sometimes <254>` new z-levels disappear and cause cave-ins. -Saving and loading after creating new z-levels should fix the problem. - -.. _liquids: - -liquids -======= -Allows adding magma, water and obsidian to the game. It replaces the normal -dfhack command line and can't be used from a hotkey. Settings will be remembered -as long as dfhack runs. Intended for use in combination with the command -``liquids-here`` (which can be bound to a hotkey). See also :issue:`80`. - -.. note:: - - Spawning and deleting liquids can mess up pathing data and - temperatures (creating heat traps). You've been warned. - -Settings will be remembered until you quit DF. You can call `liquids-here` to execute -the last configured action, which is useful in combination with keybindings. - -Usage: point the DF cursor at a tile you want to modify and use the commands. - -If you only want to add or remove water or magma from one tile, -`source` may be easier to use. - -Commands --------- -Misc commands: - -:q: quit -:help, ?: print this list of commands -:: put liquid - -Modes: - -:m: switch to magma -:w: switch to water -:o: make obsidian wall instead -:of: make obsidian floors -:rs: make a river source -:f: flow bits only -:wclean: remove salt and stagnant flags from tiles - -Set-Modes and flow properties (only for magma/water): - -:s+: only add mode -:s.: set mode -:s-: only remove mode -:f+: make the spawned liquid flow -:f.: don't change flow state (read state in flow mode) -:f-: make the spawned liquid static - -Permaflow (only for water): - -:pf.: don't change permaflow state -:pf-: make the spawned liquid static -:pf[NS][EW]: make the spawned liquid permanently flow -:0-7: set liquid amount - -Brush size and shape: - -:p, point: Single tile -:r, range: Block with cursor at bottom north-west (any place, any size) -:block: DF map block with cursor in it (regular spaced 16x16x1 blocks) -:column: Column from cursor, up through free space -:flood: Flood-fill water tiles from cursor (only makes sense with wclean) - -.. _liquids-here: - -liquids-here ------------- -Run the liquid spawner with the current/last settings made in liquids (if no -settings in liquids were made it paints a point of 7/7 magma by default). - -Intended to be used as keybinding. Requires an active in-game cursor. - -.. _plant: - -plant -===== -A tool for creating shrubs, growing, or getting rid of them. - -Subcommands: - -:create: Creates a new sapling under the cursor. Takes a raw ID as argument - (e.g. TOWER_CAP). The cursor must be located on a dirt or grass floor tile. -:grow: Turns saplings into trees; under the cursor if a sapling is selected, - or every sapling on the map if the cursor is hidden. -:extirpate: Kills the tree or shrub under the cursor, instantly turning them to ashes. -:immolate: Sets the plants on fire instead. The fires can and *will* spread ;) - -For mass effects, use one of the additional options: - -:shrubs: affect all shrubs on the map -:trees: affect all trees on the map -:all: affect every plant! - -.. _regrass: - -regrass -======= -Regrows all the grass. Not much to it ;) - -.. _restrictice: - -restrictice -=========== -Restrict traffic on all tiles on top of visible ice. -See also `alltraffic`, `filltraffic`, and `restrictliquids`. - -.. _restrictliquids: - -restrictliquids -=============== -Restrict traffic on all visible tiles with liquid. -See also `alltraffic`, `filltraffic`, and `restrictice`. - -.. _tiletypes: - -tiletypes -========= -Can be used for painting map tiles and is an interactive command, much like -`liquids`. If something goes wrong, `fixveins` may help. - -The tool works with two set of options and a brush. The brush determines which -tiles will be processed. First set of options is the filter, which can exclude -some of the tiles from the brush by looking at the tile properties. The second -set of options is the paint - this determines how the selected tiles are -changed. - -Both paint and filter can have many different properties including things like -general shape (WALL, FLOOR, etc.), general material (SOIL, STONE, MINERAL, -etc.), state of 'designated', 'hidden' and 'light' flags. - -The properties of filter and paint can be partially defined. This means that -you can for example turn all stone fortifications into floors, preserving the -material:: - - filter material STONE - filter shape FORTIFICATION - paint shape FLOOR - -Or turn mineral vein floors back into walls:: - - filter shape FLOOR - filter material MINERAL - paint shape WALL - -The tool also allows tweaking some tile flags:: - - paint hidden 1 - paint hidden 0 - -This will hide previously revealed tiles (or show hidden with the 0 option). - -More recently, the tool supports changing the base material of the tile to -an arbitrary stone from the raws, by creating new veins as required. Note -that this mode paints under ice and constructions, instead of overwriting -them. To enable, use:: - - paint stone MICROCLINE - -This mode is incompatible with the regular ``material`` setting, so changing -it cancels the specific stone selection:: - - paint material ANY - -Since different vein types have different drop rates, it is possible to choose -which one to use in painting:: - - paint veintype CLUSTER_SMALL - -When the chosen type is ``CLUSTER`` (the default), the tool may automatically -choose to use layer stone or lava stone instead of veins if its material matches -the desired one. - -Any paint or filter option (or the entire paint or filter) can be disabled entirely by using the ANY keyword:: - - paint hidden ANY - paint shape ANY - filter material any - filter shape any - filter any - -You can use several different brushes for painting tiles: - -:point: a single tile -:range: a rectangular range -:column: a column ranging from current cursor to the first solid tile above -:block: a DF map block - 16x16 tiles, in a regular grid - -Example:: - - range 10 10 1 - -This will change the brush to a rectangle spanning 10x10 tiles on one z-level. -The range starts at the position of the cursor and goes to the east, south and -up. - -For more details, use ``tiletypes help``. - -.. _tiletypes-command: - -tiletypes-command ------------------ -Runs tiletypes commands, separated by ;. This makes it possible to change -tiletypes modes from a hotkey or via dfhack-run. - -.. _tiletypes-here: - -tiletypes-here --------------- -Apply the current tiletypes options at the in-game cursor position, including -the brush. Can be used from a hotkey. - -.. _tiletypes-here-point: - -tiletypes-here-point --------------------- -Apply the current tiletypes options at the in-game cursor position to a single -tile. Can be used from a hotkey. - -.. _tubefill: - -tubefill -======== -Fills all the adamantine veins again. Veins that were hollow will be left -alone. - -Options: - -:hollow: fill in naturally hollow veins too - -Beware that filling in hollow veins will trigger a demon invasion on top of -your miner when you dig into the region that used to be hollow. - - - -================= -Mods and Cheating -================= - -.. contents:: - :local: - -.. _add-spatter: - -add-spatter -=========== -This plugin makes reactions with names starting with ``SPATTER_ADD_`` -produce contaminants on the items instead of improvements. The plugin is -intended to give some use to all those poisons that can be bought from caravans, -so they're immune to being washed away by water or destroyed by `clean`. - -.. _adv-bodyswap: - -adv-bodyswap -============ -This allows taking control over your followers and other creatures in adventure -mode. For example, you can make them pick up new arms and armor and equip them -properly. - -Usage: - -* When viewing unit details, body-swaps into that unit. -* In the main adventure mode screen, reverts transient swap. - -.. _createitem: - -createitem -========== -Allows creating new items of arbitrary types and made of arbitrary materials. -By default, items created are spawned at the feet of the selected unit. - -Specify the item and material information as you would indicate them in custom reaction raws, with the following differences: - -* Separate the item and material with a space rather than a colon -* If the item has no subtype, omit the :NONE -* If the item is REMAINS, FISH, FISH_RAW, VERMIN, PET, or EGG, - specify a CREATURE:CASTE pair instead of a material token. - -Corpses, body parts, and prepared meals cannot be created using this tool. - -Examples:: - - createitem GLOVES:ITEM_GLOVES_GAUNTLETS INORGANIC:STEEL 2 - Create 2 pairs of steel gauntlets. - createitem WOOD PLANT_MAT:TOWER_CAP:WOOD - Create tower-cap logs. - -To change where new items are placed, first run the command with a destination type while an appropriate destination is selected. - -Options: - -:floor: Subsequent items will be placed on the floor beneath the selected unit's feet. -:item: Subsequent items will be stored inside the currently selected item. -:building: Subsequent items will become part of the currently selected building. - Good for loading traps; do not use with workshops (or deconstruct to use the item). - -.. _diggingInvaders: - -diggingInvaders -=============== -Makes invaders dig or destroy constructions to get to your dwarves. - -To enable/disable the pluging, use: ``diggingInvaders (1|enable)|(0|disable)`` - -Basic usage: - -:add GOBLIN: registers the race GOBLIN as a digging invader. Case-sensitive. -:remove GOBLIN: unregisters the race GOBLIN as a digging invader. Case-sensitive. -:now: makes invaders try to dig now, if plugin is enabled -:clear: clears all digging invader races -:edgesPerTick n: makes the pathfinding algorithm work on at most n edges per tick. - Set to 0 or lower to make it unlimited. - -You can also use ``diggingInvaders setCost (race) (action) n`` to set the -pathing cost of particular action, or ``setDelay`` to set how long it takes. -Costs and delays are per-tile, and the table shows default values. - -============================== ======= ====== ================================= -Action Cost Delay Notes -============================== ======= ====== ================================= -``walk`` 1 0 base cost in the path algorithm -``destroyBuilding`` 2 1,000 delay adds to the job_completion_timer of destroy building jobs that are assigned to invaders -``dig`` 10,000 1,000 digging soil or natural stone -``destroyRoughConstruction`` 1,000 1,000 constructions made from boulders -``destroySmoothConstruction`` 100 100 constructions made from blocks or bars -============================== ======= ====== ================================= - - -.. _fastdwarf: - -fastdwarf -========= -Controls speedydwarf and teledwarf. Speedydwarf makes dwarves move quickly -and perform tasks quickly. Teledwarf makes dwarves move instantaneously, -but do jobs at the same speed. - -:fastdwarf 0: disables both (also ``0 0``) -:fastdwarf 1: enables speedydwarf and disables teledwarf (also ``1 0``) -:fastdwarf 2: sets a native debug flag in the game memory that implements an - even more aggressive version of speedydwarf. -:fastdwarf 0 1: disables speedydwarf and enables teledwarf -:fastdwarf 1 1: enables both - -See `superdwarf` for a per-creature version. - -.. _forceequip: - -forceequip -========== -Forceequip moves local items into a unit's inventory. It is typically used to -equip specific clothing/armor items onto a dwarf, but can also be used to put -armor onto a war animal or to add unusual items (such as crowns) to any unit. - -For more information run ``forceequip help``. See also `modtools/equip-item`. - -.. _lair: - -lair -==== -This command allows you to mark the map as a monster lair, preventing item -scatter on abandon. When invoked as ``lair reset``, it does the opposite. - -Unlike `reveal`, this command doesn't save the information about tiles - you -won't be able to restore state of real monster lairs using ``lair reset``. - -Options: - -:lair: Mark the map as monster lair -:lair reset: Mark the map as ordinary (not lair) - -.. _mode: - -mode -==== -This command lets you see and change the game mode directly. - -.. warning:: - - Only use ``mode`` after making a backup of your save! - - Not all combinations are good for every situation and most of them will - produce undesirable results. There are a few good ones though. - -Examples: - - * You are in fort game mode, managing your fortress and paused. - * You switch to the arena game mode, *assume control of a creature* and then - * switch to adventure game mode(1). - You just lost a fortress and gained an adventurer. Alternatively: - - * You are in fort game mode, managing your fortress and paused at the esc menu. - * You switch to the adventure game mode, assume control of a creature, then save or retire. - * You just created a returnable mountain home and gained an adventurer. - -.. _strangemood: - -strangemood -=========== -Creates a strange mood job the same way the game itself normally does it. - -Options: - -:-force: Ignore normal strange mood preconditions (no recent mood, minimum - moodable population, artifact limit not reached). -:-unit: Make the strange mood strike the selected unit instead of picking - one randomly. Unit eligibility is still enforced. -:-type : Force the mood to be of a particular type instead of choosing randomly based on happiness. - Valid values for Tare "fey", "secretive", "possessed", "fell", and "macabre". -:-skill S: Force the mood to use a specific skill instead of choosing the highest moodable skill. - Valid values are "miner", "carpenter", "engraver", "mason", "tanner", "weaver", - "clothier", "weaponsmith", "armorsmith", "metalsmith", "gemcutter", "gemsetter", - "woodcrafter", "stonecrafter", "metalcrafter", "glassmaker", "leatherworker", - "bonecarver", "bowyer", and "mechanic". - -Known limitations: if the selected unit is currently performing a job, the mood will not be started. - - -.. _siege-engine: - -siege-engine -============ -Siege engines in DF haven't been updated since the game was 2D, and can -only aim in four directions. To make them useful above-ground, -this plugin allows you to: - -* link siege engines to stockpiles -* restrict operator skill levels (like workshops) -* load any object into a catapult, not just stones -* aim at a rectangular area in any direction, and across Z-levels - -The front-end is implemented by `gui/siege-engine`. - -.. _power-meter: - -power-meter -=========== -The power-meter plugin implements a modified pressure plate that detects power being -supplied to gear boxes built in the four adjacent N/S/W/E tiles. - -The configuration front-end is implemented by `gui/power-meter`. - -.. _steam-engine: - -steam-engine -============ -The steam-engine plugin detects custom workshops with STEAM_ENGINE in -their token, and turns them into real steam engines. - -The vanilla game contains only water wheels and windmills as sources of -power, but windmills give relatively little power, and water wheels require -flowing water, which must either be a real river and thus immovable and -limited in supply, or actually flowing and thus laggy. - -Compared to the :wiki:`water reactor ` -exploit, steam engines make a lot of sense! - -Construction ------------- -The workshop needs water as its input, which it takes via a -passable floor tile below it, like usual magma workshops do. -The magma version also needs magma. - -Due to DFHack limits, the workshop will collapse over true open space. -However down stairs are passable but support machines, so you can use them. - -After constructing the building itself, machines can be connected -to the edge tiles that look like gear boxes. Their exact position -is extracted from the workshop raws. - -Like with collapse above, due to DFHack limits the workshop -can only immediately connect to machine components built AFTER it. -This also means that engines cannot be chained without intermediate -axles built after both engines. - -Operation ---------- -In order to operate the engine, queue the Stoke Boiler job (optionally -on repeat). A furnace operator will come, possibly bringing a bar of fuel, -and perform it. As a result, a "boiling water" item will appear -in the :kbd:`t` view of the workshop. - -.. note:: - - The completion of the job will actually consume one unit - of the appropriate liquids from below the workshop. This means - that you cannot just raise 7 units of magma with a piston and - have infinite power. However, liquid consumption should be slow - enough that water can be supplied by a pond zone bucket chain. - -Every such item gives 100 power, up to a limit of 300 for coal, -and 500 for a magma engine. The building can host twice that -amount of items to provide longer autonomous running. When the -boiler gets filled to capacity, all queued jobs are suspended; -once it drops back to 3+1 or 5+1 items, they are re-enabled. - -While the engine is providing power, steam is being consumed. -The consumption speed includes a fixed 10% waste rate, and -the remaining 90% are applied proportionally to the actual -load in the machine. With the engine at nominal 300 power with -150 load in the system, it will consume steam for actual -300*(10% + 90%*150/300) = 165 power. - -Masterpiece mechanism and chain will decrease the mechanical -power drawn by the engine itself from 10 to 5. Masterpiece -barrel decreases waste rate by 4%. Masterpiece piston and pipe -decrease it by further 4%, and also decrease the whole steam -use rate by 10%. - -Explosions ----------- -The engine must be constructed using barrel, pipe and piston -from fire-safe, or in the magma version magma-safe metals. - -During operation weak parts get gradually worn out, and -eventually the engine explodes. It should also explode if -toppled during operation by a building destroyer, or a -tantruming dwarf. - -Save files ----------- -It should be safe to load and view engine-using fortresses -from a DF version without DFHack installed, except that in such -case the engines won't work. However actually making modifications -to them, or machines they connect to (including by pulling levers), -can easily result in inconsistent state once this plugin is -available again. The effects may be as weird as negative power -being generated. - diff --git a/docs/Quickstart.rst b/docs/Quickstart.rst new file mode 100644 index 0000000000..10d64e0bef --- /dev/null +++ b/docs/Quickstart.rst @@ -0,0 +1,239 @@ +.. _quickstart: + +Quickstart guide +================ + +Welcome to DFHack! This guide will help get you oriented with the DFHack system +and teach you how to find and use the tools productively. If you're reading this +in the in-game `quickstart-guide` reader, hit the right arrow key or click on +the hotkey hint in the lower right corner of the window to go to the next page. + +What is DFHack? +--------------- + +DFHack is an add-on for Dwarf Fortress that enables mods and tools to +significantly extend the game. The default DFHack distribution contains a wide +variety of these mods and tools, including bugfixes, interface improvements, +automation agents, design blueprints, modding building blocks, and more. +Third-party tools (e.g. mods downloaded from Steam Workshop or the forums) can +also seamlessly integrate with the DFHack framework and extend the game far +beyond what can be done by just modding the raws. + +DFHack's mission is to provide tools and interfaces for players and modders to: + +- expand the bounds of what is possible in Dwarf Fortress +- reduce the impact of game bugs +- give the player more agency and control over the game +- provide alternatives to toilsome or frustrating aspects of gameplay +- **make the game more fun** + +What can I do with DFHack tools? +-------------------------------- + +DFHack has been around for a long time -- almost as long as Dwarf Fortress +itself. Many of the game's rough edges have been smoothed with DFHack tools. +Here are some common tasks people use DFHack tools to accomplish: + +- Automatically chop trees when log stocks are low +- Mark all damaged items for trade in a single click +- Copy and paste fort layouts +- Import and export lists of manager orders +- Clean contaminants from map squares that dwarves can't reach +- Automatically butcher excess livestock so you don't become overrun with + animals +- Promote time-sensitive job types (e.g. food hauling) so they are done + expediently +- Quickly scan the map for visible ores of specific types so you can focus + your mining efforts + +Some tools are one-shot commands. For example, you can run +`unforbid all ` to claim all (reachable) items on the map after a +messy siege. + +Other tools must be `enabled ` once and then they will run in the +background. For example, once enabled, `seedwatch` will start monitoring your +stocks of seeds and prevent your chefs from cooking seeds that you need for +planting. Tools that are enabled in the context of a fort will save their state +with that fort, and they will remember that they are enabled the next time you +load your save. You can see which tools you have enabled and toggle their states +in `gui/control-panel`. + +A third class of tools adds information to the screen or provides new integrated +functionality via the DFHack `overlay` framework. For example, the `sort` tool +adds widgets to the squad member selection screen that allow you to sort and +filter the list of military candidates. You don't have to run any command to get +the benefits of the tool, it appears automatically when you're on the relevant +screen. + +How can I figure out which commands to run? +------------------------------------------- + +There are several ways to scan DFHack tools and find the ones you need right +now. + +The first place to check is the DFHack logo menu. It's in the upper left corner +of the screen by default, though you can move it anywhere you want with the +`gui/overlay` configuration UI. + +When you click on the logo (or hit the Ctrl-Shift-C keyboard shortcut), a short +list of popular, relevant DFHack tools comes up. These are the tools that have +been assigned hotkeys that are active in the current context. For example, when +you're looking at a fort map, the list will contain fortress design tools like +`gui/quickfort` and `gui/design`. You can click on the tools in the list, or +note the hotkeys listed next to them and maybe use them to launch the tool next +time without even opening the logo menu. + +The second place to check is the DFHack control panel: `gui/control-panel`. It +will give you an overview of which tools are currently enabled, and will allow +you to toggle tools on or off, see help text for them, or launch their +dedicated configuration UIs. You can open the control panel from anywhere with +the Ctrl-Shift-E hotkey or by selecting it from the logo menu list. + +In the control panel, you can also select which tools you'd like to be +automatically enabled and popular commands you'd like to run when you start a +new fort. On the "Preferences" tab, there are settings you can change, like +"mortal mode" (you'll learn more about this in the next section) or whether you +want DFHack windows to pause the game when they come up. + +Finally, you can explore the full extent of the DFHack catalog in +`gui/launcher`, which is always listed first in the DFHack logo menu list. You +can bring up the launcher by tapping the backtick key (\`) or hitting +Ctrl-Shift-D. In the launcher, you can quickly autocomplete any command name by +selecting it in the list on the right side of the window. You can filter the list +by command tag, for example, you can see only productivity tools by setting the +"productivity" tag to "include" in the filter panel. Commands are ordered by how +often you run them, so your favorite commands will always be on top. You can +also pull full commandlines out of your history with Alt-S or by clicking on the +"history search" button. + +Once you have typed (or autocompleted, or searched for) a command, other +commands related to the one you have selected will appear in the right-hand +panel. Scanning through that list is a great way to learn about new tools that +you might find useful. + +The bottom panel will show the full help text for the command you are running, +allowing you to refer to the usage documentation and examples when you are +typing your command. After you run a command, the bottom panel switches to +command output mode, but you can get back to the help text by hitting Ctrl-T or +clicking on the ``Help`` tab. + +What if I don't want to be tempted by god-mode tools? +----------------------------------------------------- + +DFHack can give you god-like powers over the game. Sometimes, this is necessary +to recover from game-breaking bugs. Sometimes, this is desirable so players can +create specific role playing environments and situations. Sometimes, this is just +fun : ) + +But sometimes the knowledge that you can just "Armok" your way out of trouble +detracts from the game experience. If this is the way you feel, you can hide +DFHack's god-mode tools -- they all have the tag "armok" -- from the game. Open +`gui/control-panel` and go to the "Preferences" tab. Enable "Mortal mode" to +hide all "armok" tools. You can still access them in `gui/launcher` if you type +their names in full, but they won't show up in autocomplete lists, in the output +of `ls`, or anywhere else. Any global hotkeys that run "armok" tools will be +disabled. + +How do DFHack in-game windows work? +----------------------------------- + +Many DFHack tools have graphical interfaces that appear in-game. You can tell +which windows belong to DFHack tools because they will have the word "DFHack" +printed across their bottom frame edge. DFHack provides an advanced windowing +system that gives the player a lot of control over where the windows appear and +whether they capture keyboard and mouse input. + +The DFHack windowing system allows multiple overlapping windows to be active at +once. The one with the highlighted title bar has focus and will receive anything +you type at the keyboard. Hit Esc or right click to close the window or cancel +the current action. You can click anywhere on the screen that is not a DFHack +window to unfocus the window and let it just sit in the background. It won't +respond to key presses or mouse clicks until you click on it again to give it +focus. If no DFHack windows are focused, you can right click directly on a +window to close it without left clicking to focus it first. + +DFHack windows are draggable from the title bar or from anywhere on the window +that doesn't have a mouse-clickable widget on it. Many are resizable as well +(if the tool window has components that can reasonably be resized). + +You can generally use DFHack tools without interrupting the game. That is, if +the game is unpaused, it can continue to run while a DFHack window is open. If +configured to do so in `gui/control-panel`, tools will initially pause the game +to let you focus on the task at hand, but you can unpause like normal if you +want. You can also interact with the map, scrolling it with the keyboard or +mouse and selecting units, buildings, and items. Some tools, like +`gui/blueprint`, will intercept all mouse clicks to allow you to select regions +of the map. When these tools have focus, you will not be able to use the mouse +to interact with map elements or pause/unpause the game. Therefore, these tools +will pause the game when they open, regardless of your settings in +`gui/control-panel`. You can still unpause with the keyboard (spacebar by +default), though. + +Where do I go next? +------------------- + +To recap: + +You can get to popular, relevant tools for the current context by clicking on +the DFHack logo or by hitting Ctrl-Shift-C. + +You can enable DFHack tools and configure settings with `gui/control-panel`, +which you can open from the DFHack logo or access directly with the +Ctrl-Shift-E hotkey. + +You can get to the launcher and its integrated autocomplete, history search, +and help text by hitting backtick (\`) or Ctrl-Shift-D, or, of course, by +running it from the logo menu list. + +With those three interfaces, you have the complete DFHack tool suite at your +fingertips. So what to run first? Here are a few examples to get you started. + +First, let's import some useful manager orders to keep your fort stocked with +basic necessities. Run ``orders import library/basic``. If you go to your +manager orders screen, you can see all the orders that have been created for +you. Note that you could have imported the orders directly from this screen as +well, using the DFHack `overlay` widget at the bottom of the manager orders +panel. + +Next, try setting up `autochop` to automatically designate trees for chopping +when you get low on usable logs. Run `gui/control-panel` and enable +``autochop`` in the ``Automation`` -> ``Enabled`` tab. Click on the button to +the left of the name or hit Enter to enable it. You can then click on the +configure button (the gear icon) to launch `gui/autochop` if you'd like to +customize its settings (the defaults are usually fine). If you have the extra +screen space, you can go ahead and set the `gui/autochop` window to minimal +mode (click on the button near the upper right corner of the window or hit +Alt-M) and click on the map so the window loses keyboard focus. As you play +the game, you can glance at the live status panel to check on your stocks of +wood. + +Finally, let's do some fort design copy-pasting. Go to some bedrooms that you +have set up in your fort. Run `gui/blueprint`, set a name for your blueprint by +clicking on the name field (or hitting the 'n' hotkey). Type "rooms" (or +whatever) and hit Enter to set. Then draw a box around the target area by +clicking with the mouse. When you select the second corner, the blueprint will +be saved to your ``dfhack-config/blueprints`` subfolder. + +Now open up `gui/quickfort` (the hotkey is Ctrl-Shift-Q). You can search for the +blueprint you just created by typing its name, but it should be up near the top +already. If you copied a dug-out area with furniture in it, you will see two +blueprints with the labels "/dig" and "/build". Click on the "/dig" blueprint or +select it with the keyboard arrow keys and hit Enter. You can rotate or flip the +blueprint around if you need to with the transform hotkeys. You'll see a preview +of where the blueprint will be applied as you move the mouse cursor around the +map. Red outlines mean that the blueprint may fail to fully apply at that +location, so be sure to choose a spot where all the preview tiles are shown with +green diamonds. Click the mouse or hit Enter to apply the blueprint and +designate the tiles for digging. Your dwarves will come and dig it out as if you +had designated the tiles yourself. + +Once the area is dug out, run `gui/quickfort` again and select the "/build" +blueprint this time. Hit ``o`` to generate manager orders for the required +furniture. Click to apply the blueprint in the dug-out area, and your furniture +will be designated. It's just that easy! Note that `quickfort` uses +`buildingplan` to place buildings, so you don't even need to have the relevant +furniture or building materials in stock yet. The planned furniture/buildings +will get built whenever you are able to produce the building materials. + +There are many, many more tools to explore. Poke around or ask other player for +advice. Have fun, and dig deep! diff --git a/docs/Scripts.rst b/docs/Scripts.rst deleted file mode 100644 index 0e6ef415c7..0000000000 --- a/docs/Scripts.rst +++ /dev/null @@ -1,17 +0,0 @@ -############## -DFHack Scripts -############## - -Lua or ruby scripts placed in the :file:`hack/scripts/` directory -are considered for execution as if they were native DFHack commands. - -The following pages document all the scripts in the DFHack standard library. - -.. toctree:: - :maxdepth: 2 - - /docs/_auto/base - /docs/_auto/devel - /docs/_auto/fix - /docs/_auto/gui - /docs/_auto/modtools diff --git a/docs/Tags.rst b/docs/Tags.rst new file mode 100644 index 0000000000..55bfde977b --- /dev/null +++ b/docs/Tags.rst @@ -0,0 +1,52 @@ +:orphan: + +.. _tag-list: + +DFHack tool tags +================ + +A tool often has at least one tag per group, encompassing when you use the tool, +why you might want to use it, and what kind of thing you're trying to affect. + +See https://docs.google.com/spreadsheets/d/1hiDlo8M_bB_1jE-5HRs2RrrA_VZ4cRu9VXaTctX_nwk/edit#gid=1774645373 +for the tag assignment spreadsheet. + +"when" tags +----------- +- `adventure `: Tools that are useful while in adventure mode. +- `dfhack `: Tools that you use to run DFHack commands or interact with the DFHack or DF system. +- `embark `: Tools that are useful while on the fort embark screen or while creating an adventurer. +- `fort `: Tools that are useful while in fort mode. +- `legends `: Tools that are useful while in legends mode. + +"why" tags +---------- +- `armok `: Tools which give the player god-like powers or the ability to access information the game intentionally keeps hidden. Players that do not wish to see these tools can hide them in the ``Preferences`` tab of `gui/control-panel`. +- `auto `: Tools that run in the background and automatically manage routine, toilsome aspects of your fortress. +- `bugfix `: Tools that fix specific bugs, either permanently or on-demand. +- `design `: Tools that help you with fort layout. +- `dev `: Tools that are useful when debugging or developing mods. +- `fps `: Tools that help you prevent impact to your FPS. +- `gameplay `: Tools that introduce new gameplay elements. +- `inspection `: Tools that let you view information that is otherwise difficult to find. +- `productivity `: Tools that help you perform common tasks quickly and easily. + +"what" tags +----------- +- `animals `: Tools that interact with animals. +- `buildings `: Tools that interact with buildings and furniture. +- `graphics `: Tools that interact with game graphics. +- `interface `: Tools that interact with or extend the DF user interface. +- `items `: Tools that interact with in-game items. +- `jobs `: Tools that interact with jobs. +- `labors `: Tools that deal with labor assignment. +- `map `: Tools that interact with the game map. +- `military `: Tools that interact with the military. +- `plants `: Tools that interact with grass, trees, shrubs, and crops. +- `stockpiles `: Tools that interact with stockpiles. +- `units `: Tools that interact with units. +- `workorders `: Tools that interact with workorders. + +"misc" tags +----------- +- `unavailable `: Tools that are not yet available for the current release. diff --git a/docs/Tools.rst b/docs/Tools.rst new file mode 100644 index 0000000000..67d7edc54b --- /dev/null +++ b/docs/Tools.rst @@ -0,0 +1,69 @@ +.. _tools: + +DFHack tools +============ + +DFHack comes with **a lot** of tools. This page attempts to make it clearer +what they are, how they work, and how to find the ones you want. + +.. contents:: Contents + :local: + +What tools are and how they work +-------------------------------- + +DFHack is a Dwarf Fortress memory access and modification framework, so DFHack +tools normally access Dwarf Fortress internals and make some specific changes. + +Some tools just make a targeted change when you run them, like `unforbid`, which +scans through all your items and removes the ``forbidden`` flag from each of +them. + +Some tools need to be enabled, and then they run in the background and make +changes to the game on your behalf, like `autobutcher`, which monitors your +livestock population and automatically marks excess animals for butchering. + +And some tools just exist to give you information that is otherwise hard to +come by, like `gui/petitions`, which shows you the active petitions for +guildhalls and temples that you have agreed to. + +Finding the tool you need +------------------------- + +DFHack tools are tagged with categories to make them easier to find. These +categories are listed in the next few sections. Note that a tool can belong to +more than one category. If you already know what you're looking for, try the +`search` or Ctrl-F on this page. If you'd like to see the full list of tools in +one flat list, please refer to the `annotated index `. + +Some tools are part of our back catalog and haven't been updated yet for v50 of +Dwarf Fortress. These tools are tagged as +`unavailable `. They will still appear in the +alphabetical list at the bottom of this page, but unavailable tools will not +listed in any of the indices. + +DFHack tools by game mode +------------------------- + +.. include:: tags/bywhen.rst + +DFHack tools by theme +--------------------- + +.. include:: tags/bywhy.rst + +DFHack tools by what they affect +-------------------------------- + +.. include:: tags/bywhat.rst + +All DFHack tools alphabetically +------------------------------- + +.. toctree:: + :glob: + :maxdepth: 1 + :titlesonly: + + tools/* + tools/*/* diff --git a/docs/about/Authors.rst b/docs/about/Authors.rst new file mode 100644 index 0000000000..a154d314b6 --- /dev/null +++ b/docs/about/Authors.rst @@ -0,0 +1,274 @@ +List of authors +=============== +The following is a list of people who have contributed to DFHack, in +alphabetical order. + +If you should be here and aren't, please get in touch on Discord or the forums, +or make a pull request! + +======================= ======================= =========================== +Name Github Other +======================= ======================= =========================== +8Z 8Z +Abel abstern +acwatkins acwatkins +Aleksandr Glotov glotov4 +Alex Blamey Cubittus +Alexander Collins gearsix +Alexander Gavrilov angavrilov ag +Amber Brown hawkowl +Amostubal Amostubal +Andrea Cattaneo acattaneo88 +AndreasPK AndreasPK +Andriel Chaoti AndrielChaoti +Angus Mezick amezick +Antalia tamarakorr +Anuradha Dissanayake falconne +Ariphaos Ariphaos +arzyu arzyu +Atkana Atkana +AtomicChicken AtomicChicken +Batt Mush hobotron-df +Bearskie Bearskie +belal jimhester +Ben Lubar BenLubar +Ben Rosser TC01 +Benjamin McKenna britishben +Benjamin Seiller bseiller RedDwarfStepper +billw2012 billw2012 +BrickViking brickviking +brndd brndd burneddi +Caldfir caldfir +Cameron Ewell Ozzatron +Carter Bray Qartar +Chris Dombroski cdombroski +Chris Parsons chrismdp +Christian Doczkal chdoc +cjhammel cjhammel +Clayton Hughes +Clément Vuchener cvuchener +Corey CoreyJ87 +daedsidog daedsidog +Dan Amlund danamlund +Daniel Brooks db48x +David Nilsolm +David Corbett dscorbett +David Seguin dseguin +David Timm dtimm +Dean Golden LightHardt +Deon +dhthwy dhthwy +dikbutdagrate Tjudge1 +Dmitrii Kurkin Kurkin +DoctorVanGogh DoctorVanGogh +Donald Ruegsegger hashaash +doomchild doomchild +Droseran Droseran +dvantwisk dvantwisk +DwarvenM DwarvenM +Eamon Bode eamondo2 Baron Von Munchhausen +EarthPulseAcademy EarthPulseAcademy +ElMendukol ElMendukol +ElsaTheHobo ElsaTheHobo Elsa +enjia2000 +Eric Wald eswald +Erik Youngren Artanis +Espen Wiborg +expwnent expwnent +Feng +figment figment +Gabe Rau gaberau +Gaelmare Gaelmare +gchristopher gchristopher +George Murray GitOnUp +grubsteak grubsteak +Guilherme Abraham GuilhermeAbraham +Harlan Playford playfordh +Hayati Ayguen hayguen +Herwig Hochleitner bendlas +Hevlikn Hevlikn +Ian S kremlin- +IndigoFenix +Jacek Konieczny Jajcus +James 20k +James Gilles kazimuth +James Logsdon jlogsdon +Janeene Beeforth dawnmist +Jared Adams +Jeremy Apthorp nornagon +Jim Lisi stonetoad +Jimbo Whales jimbowhales +jimcarreer jimcarreer +jj jjyg jj\`\` +Joel Meador janxious +John Beisley huin +John Cosker johncosker +John Shade gsvslto +Johnny Fisher jfisher446 JohnnyWing +Jonas Ask +Jonathan Clark AridTag +Josh Cooper cppcooper coope +jowario jowario +kane-t kane-t +Kelly Kinkade ab9rf +Kelvie Wong kelvie +Kib Arekatír arekatir +KlonZK KlonZK +Kris Parker kaypy +Kristjan Moore kristjanmoore +Kromtec Kromtec +Kurik Amudnil +Kévin Boissonneault KABoissonneault +Lethosor lethosor +LordGolias LordGolias +Mark Nielson pseudodragon +Mason11987 Mason11987 +Matt Regul mattregul +Matthew Cline +Matthew Lindner mlindner +Matthew Taylor ymber yutna +Max maxthyme Max^TM +Maxim Verkhov nibirubingus +McArcady McArcady +melkor217 melkor217 +Meneth32 +Meph +Michael Casadevall NCommander +Michael Crouch creidieki +Michon van Dooren MaienM +miffedmap miffedmap +Mike Stewart thewonderidiot +Mikhail Panov Halifay +Mikko Juola Noeda Adeon +Milo Christiansen milochristiansen +MithrilTuxedo MithrilTuxedo +mizipzor mizipzor +moversti moversti +mrrho mrrho +Murad Beybalaev Erquint +Myk Taylor myk002 +Najeeb Al-Shabibi master-spike +napagokc napagokc +Neil Little nmlittle +Nicholas McDaniel NicksWorld +Nick Rart nickrart comestible +Nicolas Ayala nicolasayala +Nik Nyby nikolas +Nikolay Amiantov abbradar +nocico nocico +NotRexButCaesar NotRexButCaesar +Nuno Fernandes UnknowableCoder +nuvu vallode +Omniclasm +Ong Ying Gao ong-yinggao98 +oorzkws oorzkws +OwnageIsMagic OwnageIsMagic +pajawojciech pajawojciech +palenerd dlmarquis +PassionateAngler PassionateAngler +Patrik Lundell PatrikLundell +Paul Fenwick pjf +PeridexisErrant PeridexisErrant +Peter Hansen previsualconsent +Petr Mrázek peterix +Pfhreak Pfhreak +Pierre Lulé plule +Pierre-David Bélanger pierredavidbelanger +PopnROFL PopnROFL +potato +ppaawwll ppaawwll ðŸ‡ðŸ‡ðŸ‡ðŸ‡ +Priit Laes plaes +PrzemysÅ‚aw Skrobot frogi16 +psychowico wiktor-obrebski +Putnam Putnam3145 +quarque2 quarque2 +Quietust quietust _Q +RafaÅ‚ Karczmarczyk CarabusX +Raidau Raidau +Ralph Bisschops ralpha +Ramblurr Ramblurr +rampaging-poet +Raoul van Putten +Raoul XQ raoulxq +reverb +Rich Rauenzahn rrauenza +Rinin Rinin +rndmvar rndmvar +Rob Bailey actionninja +Rob Goodberry robob27 +Robert Heinrich rh73 +Robert Janetzko robertjanetzko +Rocco Moretti roccomoretti +RocheLimit +rofl0r rofl0r +root +Rose RosaryMala +Roses Pheosics +Ross M RossM +rout +Roxy TealSeer gallowsCalibrator +rubybrowncoat rubybrowncoat +Rumrusher rumrusher +RusAnon RusAnon +Ryan Bennitt ryanbennitt +Ryan Dwyer ToxicBananaParty Jimdude2435 +Ryan Williams Bumber64 Bumber +sami +scamtank scamtank +Scott Ellis StormCrow42 +Sebastian Wolfertz Enkrod +SeerSkye SeerSkye +seishuuu seishuuu +Seth Woodworth sethwoodworth +shevernitskiy shevernitskiy +Shim Panze Shim-Panze +Silver silverflyone +simon +Simon Jackson sizeak +Simon Lees simotek +Squid Coder realSquidCoder +stolencatkarma +Stoyan Gaydarov sgayda2 +Su Moth-Tolias +suokko suokko shrieker +sv-esk sv-esk +Tachytaenius wolfboyft +Tacomagic +tatoyoda600 tatoyoda600 +TaxiService TaxiService +terribleperson terribleperson +thefriendlyhacker thefriendlyhacker +TheHologram TheHologram +Theo Kalfas teolandon +therahedwig therahedwig +ThiagoLira ThiagoLira +thurin thurin +Tim Siegel softmoth +Tim Walberg twalberg +Timothy Collett danaris +Timothy Torres timothymtorres +Timur Kelman TymurGubayev +Tom Jobbins TheBloke +Tom Prince +Tommy R tommy +TotallyGatsby TotallyGatsby +Travis Hoppe thoppe orthographic-pedant +txtsd txtsd +U-glouglou\\simon +Valentin Ochs Cat-Ion +Varnavskii Aleksandr Crystalwarrior +Vitaly Pronkin pronvit mifki +ViTuRaS ViTuRaS +Vjek vjek +Vladimir Florov foxxelias +Warmist warmist +Wes Malone wesQ3 +Will H TSM-EVO +Will Rogers wjrogers +WoosterUK WoosterUK +XianMaeve XianMaeve +ZechyW ZechyW +Zhentar Zhentar +zilpin zilpin +Zishi Wu zishiwu123 +======================= ======================= =========================== diff --git a/docs/about/History.rst b/docs/about/History.rst new file mode 100644 index 0000000000..4bd4ec6429 --- /dev/null +++ b/docs/about/History.rst @@ -0,0 +1,3979 @@ +:orphan: + +.. _History: + +##################### +Historical changelogs +##################### + +This file is where old changelogs live, so the `current changelog ` +doesn't get too long. Some of these changelogs are also formatted differently +from current changelogs and would be difficult for the current `changelog +generation system ` to handle. + +.. contents:: Contents + :local: + :depth: 1 + +DFHack 0.47.05-r8 +================= + +New Plugins +----------- +- `channel-safely`: auto-manage channel designations to keep dwarves safe +- `overlay`: plugin is transformed from a single line of text that runs `gui/launcher` on click to a fully-featured overlay injection framework. It now houses a popup menu for keybindings relevant to the current DF screen, all the widgets previously provided by `dwarfmonitor` (e.g. the current date and number of happy/unhappy dwarves), the overlay that highlights suspended buildings when you pause, and others. See `overlay-dev-guide` for details. + +New Scripts +----------- +- `gui/overlay`: configuration interface for the DFHack overlays and overlay widgets. includes a click-and-drag interface for repositioning widgets! + +Fixes +----- +- Core: ensure ``foo.init`` always runs before ``foo.*.init`` (e.g. ``dfhack.init`` should always run before ``dfhack.something.init``) +- `autofarm`: flush output so status text is visible immediately after running the command +- `autolabor`, `autohauler`: properly handle jobs 241, 242, and 243 +- `automaterial`: + - fix the cursor jumping up a z level when clicking quickly after box select + - fix rendering errors with box boundary markers +- `buildingplan`: fix crash when canceling out of placement mode for a building with planning mode enabled and subsequently attempting to place a building that does not have planning mode enabled and that has no pertinent materials available +- `dwarf-op`: fixed error when matching dwarves by name +- `gui/create-item`: prevent materials list filter from intercepting sublist hotkeys +- `gui/gm-unit`: fixed behavior of ``+`` and ``-`` to adjust skill values instead of populating the search field +- `hotkeys`: correctly detect hotkeys bound to number keys, F11, and F12 +- `labormanager`: associate quern construction with the correct labor +- `mousequery`: fix the cursor jumping up z levels sometimes when using TWBT +- `tiletypes`: no longer resets dig priority to the default when updating other properties of a tile +- `warn-stealers`: + - register callback with correct event name so that units entering the map are detected + - announce thieving creatures that spawn already revealed + - cache unit IDs instead of unit objects to avoid referencing stale pointers +- `workorder`: fix interpretation of json-specified orders that set the ``item_type`` field +- ``EventManager``: + - fix a segmentation fault with the ``REPORT`` event + - fix the ``JOB_STARTED`` event only sending events to the first handler listed instead of all registered handlers + +Misc Improvements +----------------- +- UX: + - List widgets now have mouse-interactive scrollbars + - You can now hold down the mouse button on a scrollbar to make it scroll multiple times. + - You can now drag the scrollbar up and down to scroll to a specific spot +- `autolabor`, `autohauler`: refactored to use DFHack's messaging system for info/debug/trace messages +- `blueprint`: + - new ``--smooth`` option for recording all smoothed floors and walls instead of just the ones that require smoothing for later carving + - record built constructions in blueprints + - record stockpile/building/zone names in blueprints + - record room sizes in blueprints + - generate meta blueprints to reduce the number of blueprints you have to apply + - support splitting the output file into phases grouped by when they can be applied + - when splitting output files, number them so they sort into the order you should apply them in +- `digtype`: new ``-z`` option for digtype to restrict designations to the current z-level and down +- `dwarfmonitor`: widgets have been ported to the overlay framework and can be enabled and configured via the `gui/overlay` UI +- `gui/blueprint`: support new blueprint phases and options +- `gui/cp437-table`: new global keybinding for the clickable on-screen keyboard for players with keyboard layouts that prevent them from using certain keys: Ctrl-Shift-K +- `gui/create-item`: restrict materials to those normally allowed by the game by default, introduce new ``--unrestricted`` option for full freedom in choosing materials +- `gui/launcher`: show help for commands that start with ':' (like ``:lua``) +- `gui/quantum`: add option to allow corpses and refuse in your quantum stockpile +- `hotkeys`: + - hotkey screen has been transformed into an interactive `overlay` widget that you can bring up by moving the mouse cursor over the hotspot (in the upper left corner of the screen by default). Enable/disable/reposition the hotspot in the `gui/overlay` UI. Even if the hotspot is disabled, the menu can be brought up at any time with the Ctrl-Shift-C hotkey. + - now supports printing active hotkeys to the console with ``hotkeys list`` +- `ls`: + - indent tag listings and wrap them in the rightmost column for better readability + - new ``--exclude`` option for hiding matched scripts from the output. this can be especially useful for modders who don't want their mod scripts to be included in ``ls`` output. +- `modtools/create-unit`: better unit naming, more argument checks, assign nemesis save data for units without civilization so they can be properly saved when offloaded +- `orders`: replace shell craft orders in the standard orders list you get with ``orders import library/basic`` with orders for shell leggings. They have a slightly higher trade price. Also, "shleggings" is just hilarious. +- `quickfort-library-guide`: improved layout of marksdwarf barracks in the example Dreamfort blueprints +- `spectate`: + - new ``auto-unpause`` option for auto-dismissal of announcement pause events (e.g. sieges). + - new ``auto-disengage`` option for auto-disengagement of plugin through player interaction whilst unpaused. + - new ``tick-threshold`` option for specifying the maximum time to follow the same dwarf + - new ``animals`` option for sometimes following animals + - new ``hostiles`` option for sometimes following hostiles + - new ``visiting`` option for sometimes following visiting merchants, diplomats or plain visitors + - added persistent configuration of the plugin settings +- `unsuspend`: new `overlay` for displaying status of suspended buildings (functionality migrated from removed `resume` plugin) + +Documentation +------------- +- `overlay-dev-guide`: documentation and guide for injecting functionality into DF viewscreens from Lua scripts and creating interactive overlay widgets +- ``dfhack.gui.revealInDwarfmodeMap``: document ``center`` bool for Lua API + +Removed +------- +- `gui/create-item`: removed ``--restricted`` option. it is now the default behavior +- `resume`: functionality (including suspended building overlay) has moved to `unsuspend` + +API +--- +- Constructions module: added ``insert()`` to insert constructions into the game's sorted list. +- MiscUtils: added the following string transformation functions (refactored from ``uicommon.h``): ``int_to_string``, ``ltrim``, ``rtrim``, and ``trim``; added ``string_to_int`` +- Units module: + - added new predicates for: + - ``isUnitInBox()`` + - ``isAnimal()`` + - ``isVisiting()`` any visiting unit (diplomat, merchant, visitor) + - ``isVisitor()`` ie. not merchants or diplomats + - ``isInvader()`` + - ``isDemon()`` returns true for unique/regular demons + - ``isTitan()`` + - ``isMegabeast()`` + - ``isGreatDanger()`` returns true if unit is a demon, titan, or megabeast + - ``isSemiMegabeast()`` + - ``isNightCreature()`` + - ``isDanger()`` returns true if is a 'GreatDanger', semi-megabeast, night creature, undead, or invader + - modified predicates: + - ``isUndead()`` now optionally ignores vampires instead of always ignoring vampires + - ``isCitizen()`` now optionally ignores insane citizens instead of always ignoring insane citizens + - new action timer API for speeding up of slowing down units +- ``Gui::anywhere_hotkey``: for plugin commands bound to keybindings that can be invoked on any screen +- ``Gui::autoDFAnnouncement``, ``Gui::pauseRecenter``: added functionality reverse-engineered from announcement code +- ``Gui::revealInDwarfmodeMap``: Now enforce valid view bounds when pos invalid, add variant accepting x, y, z +- ``Lua::Push()``: now handles maps with otherwise supported keys and values +- ``Lua::PushInterfaceKeys()``: transforms viewscreen ``feed()`` keys into something that can be interpreted by lua-based widgets + +Internals +--------- +- Constructions module: ``findAtTile`` now uses a binary search instead of a linear search +- MSVC warning level upped to /W3, and /WX added to make warnings cause compilations to fail. + +Lua +--- +- Lua mouse events now conform to documented behavior in `lua-api` -- ``_MOUSE_L_DOWN`` will be sent exactly once per mouse click and ``_MOUSE_L`` will be sent repeatedly as long as the button is held down. Similarly for right mouse button events. +- ``dfhack.constructions.findAtTile()``: exposed preexisting function to Lua. +- ``dfhack.constructions.insert()``: exposed new function to Lua. +- ``gui.Screen.show()``: now returns ``self`` as a convenience +- ``gui.View.getMousePos()`` now takes an optional ``ViewRect`` parameter in case the caller wants to get the mouse pos relative to a rect that is not the frame_body (such as the frame_rect that includes the frame itself) +- ``widgets.EditField``: now allows other widgets to process characters that the ``on_char`` callback rejects. +- ``widgets.FilteredList``: now provides a useful default search key for list items made up of text tokens instead of plain text +- ``widgets.HotkeyLabel``: now ignores mouse clicks when ``on_activate`` is not defined +- ``widgets.List``: + - new ``getIdxUnderMouse()`` function for detecting the list index under the active mouse cursor. this allows for "selection follows mouse" behavior + - shift-clicking now triggers the ``submit2`` attribute function if it is defined +- ``widgets.Panel``: new ``frame_style`` and ``frame_title`` attributes for drawing frames around groups of widgets +- ``widgets.ResizingPanel``: now accounts for frame inset when calculating frame size +- ``widgets.Scrollbar``: new scrollbar widget that can be paired with an associated scrollable widget. Integrated with ``widgets.Label`` and ``widgets.List``. + +Structures +---------- +- ``general_refst``: type virtual union member for ``ITEM_GENERAL`` +- ``historical_figure_info.T_reputation.unk_2c``: identify ``year`` + ``year_ticks`` +- ``itemst``: identify two vmethods related to adding thread improvements to items made of cloth, and label several previously unknown return types +- ``proj_magicst``: correct structure fields (to match 40d) +- ``unit_action_type_group``: added enum and tagged ``unit_action_type`` entries with its groups for DFHack's new action timer API. +- ``world``: identify type of a vector (still not known what it's for, but it's definitely an item vector) + + +DFHack 0.47.05-r7 +================= + +New Plugins +----------- +- `autobutcher`: split off from `zone` into its own plugin. Note that to enable, the command has changed from ``autobutcher start`` to ``enable autobutcher``. +- `autonestbox`: split off from `zone` into its own plugin. Note that to enable, the command has changed from ``autonestbox start`` to ``enable autonestbox``. +- `overlay`: display a "DFHack" button in the lower left corner that you can click to start the new GUI command launcher. The `dwarfmonitor` weather display had to be moved to make room for the button. If you are seeing the weather indicator rendered over the overlay button, please remove the ``dfhack-config/dwarfmonitor.json`` file to fix the weather indicator display offset. + +New Scripts +----------- +- `gui/kitchen-info`: adds more info to the Kitchen screen +- `gui/launcher`: in-game command launcher with autocomplete, history, and context-sensitive help +- `gui/workorder-details`: adjusts work orders' input item, material, traits +- `max-wave`: dynamically limit the next immigration wave, can be set to repeat +- `pop-control`: persistent per fortress population cap, `hermit`, and `max-wave` management +- `warn-stealers`: warn when creatures that may steal your food, drinks, or items become visible + +New Internal Commands +--------------------- +- `tags`: new built-in command to list the tool category tags and their definitions. tags associated with each tool are visible in the tool help and in the output of `ls`. + +Fixes +----- +- `autochop`: designate largest trees for chopping first, instead of the smallest +- `devel/query`: fixed error when --tile is specified +- `dig-now`: Fix direction of smoothed walls when adjacent to a door or floodgate +- `dwarf-op`: fixed error when applying the Miner job to dwarves +- `emigration`: fix emigrant logic so unhappy dwarves leave as designed +- `gui/gm-unit`: allow ``+`` and ``-`` to adjust skill values as intended instead of letting the filter intercept the characters +- `gui/unit-info-viewer`: fix logic for displaying undead creature names +- `gui/workflow`: restore functionality to the add/remove/order hotkeys on the workflow status screen +- `modtools/moddable-gods`: fixed an error when assigning spheres +- `quickfort`: `Dreamfort ` blueprint set: declare the hospital zone before building the coffer; otherwise DF fails to stock the hospital with materials +- `view-item-info`: fixed a couple errors when viewing items without materials +- ``dfhack.buildings.findCivzonesAt``: no longer return duplicate civzones after loading a save with existing civzones +- ``dfhack.run_script``: ensure the arguments passed to scripts are always strings. This allows other scripts to call ``run_script`` with numeric args and it won't break parameter parsing. +- ``job.removeJob()``: ensure jobs are removed from the world list when they are canceled + +Misc Improvements +----------------- +- History files: ``dfhack.history``, ``tiletypes.history``, ``lua.history``, and ``liquids.history`` have moved to the ``dfhack-config`` directory. If you'd like to keep the contents of your current history files, please move them to ``dfhack-config``. +- Init scripts: ``dfhack.init`` and other init scripts have moved to ``dfhack-config/init/``. If you have customized your ``dfhack.init`` file and want to keep your changes, please move the part that you have customized to the new location at ``dfhack-config/init/dfhack.init``. If you do not have changes that you want to keep, do not copy anything, and the new defaults will be used automatically. +- UX: + - You can now move the cursor around in DFHack text fields in ``gui/`` scripts (e.g. `gui/blueprint`, `gui/quickfort`, or `gui/gm-editor`). You can move the cursor by clicking where you want it to go with the mouse or using the Left/Right arrow keys. Ctrl+Left/Right will move one word at a time, and Alt+Left/Right will move to the beginning/end of the text. + - You can now click on the hotkey hint text in many ``gui/`` script windows to activate the hotkey, like a button. Not all scripts have been updated to use the clickable widget yet, but you can try it in `gui/blueprint` or `gui/quickfort`. + - Label widget scroll icons are replaced with scrollbars that represent the percentage of text on the screen and move with the position of the visible text, just like web browser scrollbars. +- `devel/query`: + - inform the user when a query has been truncated due to ``--maxlength`` being hit. + - increased default maxlength value from 257 to 2048 +- `do-job-now`: new global keybinding for boosting the priority of the jobs associated with the selected building/work order/unit/item etc.: Alt-N +- `dwarf-op`: replaces [ a b c ] option lists with a,b,c option lists +- `gui/gm-unit`: don't clear the list filter when you adjust a skill value +- `gui/quickfort`: + - better formatting for the generated manager orders report + - you can now click on the map to move the blueprint anchor point to that tile instead of having to use the cursor movement keys + - display an error message when the blueprints directory cannot be found +- `gui/workorder-details`: new keybinding on the workorder details screen: ``D`` +- `keybinding`: support backquote (\`) as a hotkey (and assign the hotkey to the new `gui/launcher` interface) +- `ls`: can now filter tools by substring or tag. note that dev scripts are hidden by default. pass the ``--dev`` option to show them. +- `manipulator`: + - add a library of useful default professions + - move professions configuration from ``professions/`` to ``dfhack-config/professions/`` to keep it together with other dfhack configuration. If you have saved professions that you would like to keep, please manually move them to the new folder. +- `orders`: added useful library of manager orders. see them with ``orders list`` and import them with, for example, ``orders import library/basic`` +- `prioritize`: new ``defaults`` keyword to prioritize the list of jobs that the community agrees should generally be prioritized. Run ``prioritize -a defaults`` to try it out in your fort! +- `prospect`: add new ``--show`` option to give the player control over which report sections are shown. e.g. ``prospect all --show ores`` will just show information on ores. +- `quickfort`: + - `Dreamfort ` blueprint set improvements: set traffic designations to encourage dwarves to eat cooked food instead of raw ingredients + - library blueprints are now included by default in ``quickfort list`` output. Use the new ``--useronly`` (or just ``-u``) option to filter out library blueprints. + - better error message when the blueprints directory cannot be found +- `seedwatch`: ``seedwatch all`` now adds all plants with seeds to the watchlist, not just the "basic" crops. +- ``materials.ItemTraitsDialog``: added a default ``on_select``-handler which toggles the traits. + +Documentation +------------- +- Added `modding-guide` +- Group DFHack tools by `tag ` so similar tools are grouped and easy to find +- Update all DFHack tool documentation (300+ pages) with standard syntax formatting, usage examples, and overall clarified text. + +Removed +------- +- `fix/build-location`: The corresponding DF bug (5991) was fixed in DF 0.40.05 +- `fix/diplomats`: DF bug 3295 fixed in 0.40.05 +- `fix/fat-dwarves`: DF bug 5971 fixed in 0.40.05 +- `fix/feeding-timers`: DF bug 2606 is fixed in 0.40.12 +- `fix/merchants`: DF bug that prevents humans from making trade agreements has been fixed +- `gui/assign-rack`: No longer useful in current DF versions +- `gui/hack-wish`: Replaced by `gui/create-item` +- `gui/no-dfhack-init`: No longer useful since players don't have to create their own ``dfhack.init`` files anymore + +API +--- +- Removed "egg" ("eggy") hook support (Linux only). The only remaining method of hooking into DF is by interposing SDL calls, which has been the method used by all binary releases of DFHack. +- Removed ``Engravings`` module (C++-only). Access ``world.engravings`` directly instead. +- Removed ``Notes`` module (C++-only). Access ``ui.waypoints.points`` directly instead. +- Removed ``Windows`` module (C++-only) - unused. +- ``Constructions`` module (C++-only): removed ``t_construction``, ``isValid()``, ``getCount()``, ``getConstruction()``, and ``copyConstruction()``. Access ``world.constructions`` directly instead. +- ``Gui::getSelectedItem()``, ``Gui::getAnyItem()``: added support for the artifacts screen +- ``Units::teleport()``: now sets ``unit.idle_area`` to discourage units from walking back to their original location (or teleporting back, if using `fastdwarf`) + +Lua +--- +- Added ``dfhack.screen.hideGuard()``: exposes the C++ ``Screen::Hide`` to Lua +- History: added ``dfhack.getCommandHistory(history_id, history_filename)`` and ``dfhack.addCommandToHistory(history_id, history_filename, command)`` so gui scripts can access a commandline history without requiring a terminal. +- ``helpdb``: database and query interface for DFHack tool help text +- ``tile-material``: fix the order of declarations. The ``GetTileMat`` function now returns the material as intended (always returned nil before). Also changed the license info, with permission of the original author. +- ``utils.df_expr_to_ref()``: fixed some errors that could occur when navigating tables +- ``widgets.CycleHotkeyLabel``: clicking on the widget will now cycle the options and trigger ``on_change()``. This also applies to the ``ToggleHotkeyLabel`` subclass. +- ``widgets.EditField``: + - new ``onsubmit2`` callback attribute is called when the user hits Shift-Enter. + - new function: ``setCursor(position)`` sets the input cursor. + - new attribute: ``ignore_keys`` lets you ignore specified characters if you want to use them as hotkeys +- ``widgets.FilteredList``: new attribute: ``edit_ignore_keys`` gets passed to the filter EditField as ``ignore_keys`` +- ``widgets.HotkeyLabel``: clicking on the widget will now call ``on_activate()``. +- ``widgets.Label``: ``scroll`` function now interprets the keywords ``+page``, ``-page``, ``+halfpage``, and ``-halfpage`` in addition to simple positive and negative numbers. + +Structures +---------- +- Eliminate all "anon_X" names from structure fields +- ``army``: change ``squads`` vector type to ``world_site_inhabitant``, identify ``min_smell_trigger``+``max_odor_level``+``max_low_light_vision``+``sense_creature_classes`` +- ``cave_column_rectangle``: identify coordinates +- ``cave_column``: identify Z coordinates +- ``embark_profile``: identify reclaim fields, add missing pet_count vector +- ``entity_population``: identify ``layer_id`` +- ``feature``: identify "shiftCoords" vmethod, ``irritation_level`` and ``irritation_attacks`` fields +- ``flow_guide``: identify "shiftCoords" vmethod +- ``general_refst``: name parameters on ``getLocation`` and ``setLocation`` vmethods +- ``general_ref_locationst``: name member fields +- ``historical_entity``: confirm ``hostility_level`` and ``siege_tier`` +- ``item``: identify method ``notifyCreatedMasterwork`` that is called when a masterwork is created. +- ``language_name_type``: identify ``ElfTree`` and ``SymbolArtifice`` thru ``SymbolFood`` +- ``misc_trait_type``: update auto-decrement markers, remove obsolete references +- ``timed_event``: identify ``layer_id`` +- ``ui_advmode``: identify several fields as containing coordinates +- ``ui_build_selector``: identify ``cur_walk_tag`` and ``min_weight_races``+``max_weight_races`` +- ``ui``: identify actual contents of ``unk5b88`` field, identify infiltrator references +- ``unitst``: identify ``histeventcol_id`` field inside status2 +- ``viewscreen_barterst``: name member fields +- ``viewscreen_tradegoodsst``: rename trade_reply ``OffendedAnimal``+``OffendedAnimalAlt`` to ``OffendedBoth``+``OffendedAnimal`` +- ``world_site_inhabitant``: rename ``outcast_id`` and ``founder_outcast_entity_id``, identify ``interaction_id`` and ``interaction_effect_idx`` + + +DFHack 0.47.05-r6 +================= + +New Scripts +----------- +- `assign-minecarts`: automatically assign minecarts to hauling routes that don't have one +- `deteriorate`: combines, replaces, and extends previous `deteriorateclothes`, `deterioratecorpses`, and `deterioratefood` scripts. +- `gui/petitions`: shows petitions. now you can see which guildhall/temple you agreed to build! +- `gui/quantum`: point-and-click tool for creating quantum stockpiles +- `gui/quickfort`: shows blueprint previews on the live map so you can apply them interactively +- `modtools/fire-rate`: allows modders to adjust the rate of fire for ranged attacks + +Fixes +----- +- `build-now`: walls built above other walls can now be deconstructed like regularly-built walls +- `eventful`: + - fix ``eventful.registerReaction`` to correctly pass ``call_native`` argument thus allowing canceling vanilla item creation. Updated related documentation. + - renamed NEW_UNIT_ACTIVE event to UNIT_NEW_ACTIVE to match the ``EventManager`` event name + - fixed UNIT_NEW_ACTIVE event firing too often +- `gui/dfstatus`: no longer count items owned by traders +- `gui/unit-info-viewer`: fix calculation/labeling of unit size +- ``job.removeJob()``: fixes regression in DFHack 0.47.05-r5 where items/buildings associated with the job were not getting disassociated when the job is removed. Now `build-now` can build buildings and `gui/mass-remove` can cancel building deconstruction again +- ``widgets.CycleHotkeyLabel``: allow initial option values to be specified as an index instead of an option value + +Misc Improvements +----------------- +- `build-now`: buildings that were just designated with `buildingplan` are now built immediately (as long as there are items available to build the buildings with) instead of being skipped until buildingplan gets around to doing its regular scan +- `caravan`: new ``unload`` command, fixes endless unloading at the depot by reconnecting merchant pack animals that were disconnected from their owners +- `confirm`: + - added a confirmation dialog for removing manager orders + - allow players to pause the confirmation dialog until they exit the current screen +- `deteriorate`: new ``now`` command immediately deteriorates items of the specified types +- `dfhack-examples-guide`: + - refine food preparation orders so meal types are chosen intelligently according to the amount of meals that exist and the number of available items to cook with + - reduce required stock of dye for "Dye cloth" orders + - fix material conditions for making jugs and pots + - make wooden jugs by default to differentiate them from other stone tools. this allows players to more easily select jugs out with a properly-configured stockpile (i.e. the new ``woodentools`` alias) +- `list-agreements`: now displays translated guild names, worshipped deities, petition age, and race-appropriate professions (e.g. "Craftsdwarf" instead of "Craftsman") +- `quickfort-alias-guide`: + - new aliases: ``forbidsearch``, ``permitsearch``, and ``togglesearch`` use the `search-plugin` plugin to alter the settings for a filtered list of item types when configuring stockpiles + - new aliases: ``stonetools`` and ``woodentools``. the ``jugs`` alias is deprecated. please use ``stonetools`` instead, which is the same as the old ``jugs`` alias. + - new aliases: ``usablehair``, ``permitusablehair``, and ``forbidusablehair`` alter settings for the types of hair/wool that can be made into cloth: sheep, llama, alpaca, and troll. The ``craftrefuse`` aliases have been altered to use this alias as well. + - new aliases: ``forbidthread``, ``permitthread``, ``forbidadamantinethread``, ``permitadamantinethread``, ``forbidcloth``, ``permitcloth``, ``forbidadamantinecloth``, and ``permitadamantinecloth`` give you more control how adamantine-derived items are stored +- `quickfort`: + - `Dreamfort ` blueprint set improvements: automatically create tavern, library, and temple locations (restricted to residents only by default), automatically associate the rented rooms with the tavern + - `Dreamfort ` blueprint set improvements: new design for the services level, including were-bitten hospital recovery rooms and an appropriately-themed interrogation room next to the jail! Also fits better in a 1x1 embark for minimalist players. +- `workorder`: a manager is no longer required for orders to be created (matching behavior in the game itself) + +Removed +------- +- `deteriorateclothes`: please use ``deteriorate --types=clothes`` instead +- `deterioratecorpses`: please use ``deteriorate --types=corpses`` instead +- `deterioratefood`: please use ``deteriorate --types=food`` instead +- `devel/unforbidall`: please use `unforbid` instead. You can silence the output with ``unforbid all --quiet`` + +API +--- +- ``word_wrap``: argument ``bool collapse_whitespace`` converted to enum ``word_wrap_whitespace_mode mode``, with valid modes ``WSMODE_KEEP_ALL``, ``WSMODE_COLLAPSE_ALL``, and ``WSMODE_TRIM_LEADING``. + +Lua +--- +- ``gui.View``: all ``View`` subclasses (including all ``Widgets``) can now acquire keyboard focus with the new ``View:setFocus()`` function. See docs for details. +- ``materials.ItemTraitsDialog``: new dialog to edit item traits (where "item" is part of a job or work order or similar). The list of traits is the same as in vanilla work order conditions "``t`` change traits". +- ``widgets.EditField``: + - the ``key_sep`` string is now configurable + - can now display an optional string label in addition to the activation key + - views that have an ``EditField`` subview no longer need to manually manage the ``EditField`` activation state and input routing. This is now handled automatically by the new ``gui.View`` keyboard focus subsystem. +- ``widgets.HotkeyLabel``: the ``key_sep`` string is now configurable + +Structures +---------- +- ``art_image_elementst``: identify vmethod ``markDiscovered`` and second parameter for ``getName2`` +- ``art_image_propertyst``: identify parameters for ``getName`` +- ``building_handler``: fix vmethod ``get_machine_hookup_list`` parameters +- ``vermin``: identify ``category`` field as new enum +- ``world.unk_26a9a8``: rename to ``allow_announcements`` + + +DFHack 0.47.05-r5 +================= + +New Plugins +----------- +- `spectate`: "spectator mode" -- automatically follows dwarves doing things in your fort + +New Scripts +----------- +- `devel/eventful-client`: useful for testing eventful events + +New Tweaks +---------- +- `tweak`: ``partial-items`` displays percentage remaining for partially-consumed items such as hospital cloth + +Fixes +----- +- `autofarm`: removed restriction on only planting "discovered" plants +- `cxxrandom`: fixed exception when calling ``bool_distribution`` +- `devel/query`: + - fixed a problem printing parents when the starting path had lua pattern special characters in it + - fixed a crash when trying to iterate over linked lists +- `gui/advfort`: encrust and stud jobs no longer consume reagents without actually improving the target item +- `luasocket`: return correct status code when closing socket connections so clients can know when to retry +- `quickfort`: constructions and bridges are now properly placed over natural ramps +- `setfps`: keep internal ratio of processing FPS to graphics FPS in sync when updating FPS + +Misc Improvements +----------------- +- `autochop`: + - only designate the amount of trees required to reach ``max_logs`` + - preferably designate larger trees over smaller ones +- `autonick`: + - now displays help instead of modifying dwarf nicknames when run without parameters. use ``autonick all`` to rename all dwarves. + - added ``--quiet`` and ``--help`` options +- `blueprint`: + - ``track`` phase renamed to ``carve`` + - carved fortifications and (optionally) engravings are now captured in generated blueprints +- `cursecheck`: new option, ``--ids`` prints creature and race IDs of the cursed creature +- `debug`: + - DFHack log messages now have configurable headers (e.g. timestamp, origin plugin name, etc.) via the ``debugfilter`` command of the `debug` plugin + - script execution log messages (e.g. "Loading script: dfhack_extras.init" can now be controlled with the ``debugfilter`` command. To hide the messages, add this line to your ``dfhack.init`` file: ``debugfilter set Warning core script`` +- `dfhack-examples-guide`: + - add mugs to ``basic`` manager orders + - ``onMapLoad_dreamfort.init`` remove "cheaty" commands and new tweaks that are now in the default ``dfhack.init-example`` file +- `dig-now`: handle fortification carving +- `EventManager`: + - add new event type ``JOB_STARTED``, triggered when a job first gains a worker + - add new event type ``UNIT_NEW_ACTIVE``, triggered when a new unit appears on the active list +- `gui/blueprint`: support new `blueprint` options and phases +- `gui/create-item`: Added "(chain)" annotation text for armours with the [CHAIN_METAL_TEXT] flag set +- `manipulator`: tweak colors to make the cursor easier to locate +- `quickfort`: + - support transformations for blueprints that use expansion syntax + - adjust direction affinity when transforming buildings (e.g. bridges that open to the north now open to the south when rotated 180 degrees) + - automatically adjust cursor movements on the map screen in ``#query`` and ``#config`` modes when the blueprint is transformed. e.g. ``{Up}`` will be played back as ``{Right}`` when the blueprint is rotated clockwise and the direction key would move the map cursor + - new blueprint mode: ``#config``; for playing back key sequences that don't involve the map cursor (like configuring hotkeys, changing standing orders, or modifying military uniforms) + - API function ``apply_blueprint`` can now take ``data`` parameters that are simple strings instead of coordinate maps. This allows easier application of blueprints that are just one cell. +- `stocks`: allow search terms to match the full item label, even when the label is truncated for length +- `tweak`: ``stable-cursor`` now keeps the cursor stable even when the viewport moves a small amount +- ``dfhack.init-example``: recently-added tweaks added to example ``dfhack.init`` file + +Documentation +------------- +- add more examples to the plugin example skeleton files so they are more informative for a newbie +- update download link and installation instructions for Visual C++ 2015 build tools on Windows +- update information regarding obtaining a compatible Windows build environment +- `confirm`: correct the command name in the plugin help text +- `cxxrandom`: added usage examples +- `lua-string`: document DFHack string extensions (``startswith()``, ``endswith()``, ``split()``, ``trim()``, ``wrap()``, and ``escape_pattern()``) +- `quickfort-blueprint-guide`: added screenshots to the Dreamfort case study and overall clarified text +- `remote-client-libs`: add new Rust client library +- ``Lua API.rst``: added ``isHidden(unit)``, ``isFortControlled(unit)``, ``getOuterContainerRef(unit)``, ``getOuterContainerRef(item)`` + +API +--- +- add functions reverse-engineered from ambushing unit code: ``Units::isHidden()``, ``Units::isFortControlled()``, ``Units::getOuterContainerRef()``, ``Items::getOuterContainerRef()`` +- ``Job::removeJob()``: use the job cancel vmethod graciously provided by The Toady One in place of a synthetic method derived from reverse engineering + +Lua +--- +- `custom-raw-tokens`: library for accessing tokens added to raws by mods +- ``dfhack.units``: Lua wrappers for functions reverse-engineered from ambushing unit code: ``isHidden(unit)``, ``isFortControlled(unit)``, ``getOuterContainerRef(unit)``, ``getOuterContainerRef(item)`` +- ``dialogs``: ``show*`` functions now return a reference to the created dialog +- ``dwarfmode.enterSidebarMode()``: passing ``df.ui_sidebar_mode.DesignateMine`` now always results in you entering ``DesignateMine`` mode and not ``DesignateChopTrees``, even when you looking at the surface (where the default designation mode is ``DesignateChopTrees``) +- ``dwarfmode.MenuOverlay``: + - if ``sidebar_mode`` attribute is set, automatically manage entering a specific sidebar mode on show and restoring the previous sidebar mode on dismiss + - new class function ``renderMapOverlay`` to assist with painting tiles over the visible map +- ``ensure_key``: new global function for retrieving or dynamically creating Lua table mappings +- ``safe_index``: now properly handles lua sparse tables that are indexed by numbers +- ``string``: new function ``escape_pattern()`` escapes regex special characters within a string +- ``widgets``: + - unset values in ``frame_inset`` table default to ``0`` + - ``FilteredList`` class now allows all punctuation to be typed into the filter and can match search keys that start with punctuation + - minimum height of ``ListBox`` dialog is now calculated correctly when there are no items in the list (e.g. when a filter doesn't match anything) + - if ``autoarrange_subviews`` is set, ``Panel``\s will now automatically lay out widgets vertically according to their current height. This allows you to have widgets dynamically change height or become visible/hidden and you don't have to worry about recalculating frame layouts + - new class ``ResizingPanel`` (subclass of ``Panel``) automatically recalculates its own frame height based on the size, position, and visibility of its subviews + - new class ``HotkeyLabel`` (subclass of ``Label``) that displays and reacts to hotkeys + - new class ``CycleHotkeyLabel`` (subclass of ``Label``) allows users to cycle through a list of options by pressing a hotkey + - new class ``ToggleHotkeyLabel`` (subclass of ``CycleHotkeyLabel``) toggles between ``On`` and ``Off`` states + - new class ``WrappedLabel`` (subclass of ``Label``) provides autowrapping of text + - new class ``TooltipLabel`` (subclass of ``WrappedLabel``) provides tooltip-like behavior + +Structures +---------- +- ``adventure_optionst``: add missing ``getUnitContainer`` vmethod +- ``historical_figure.T_skills``: add ``account_balance`` field +- ``job``: add ``improvement`` field (union with ``hist_figure_id`` and ``race``) +- ``report_init.flags``: rename ``sparring`` flag to ``hostile_combat`` +- ``viewscreen_loadgamest``: add missing ``LoadingImageSets`` and ``LoadingDivinationSets`` enum values to ``cur_step`` field + + +DFHack 0.47.05-r4 +================= + +Fixes +----- +- `blueprint`: + - fixed passing incorrect parameters to `gui/blueprint` when you run ``blueprint gui`` with optional params + - key sequences for constructed walls and down stairs are now correct +- `exportlegends`: fix issue where birth year was outputted as birth seconds +- `quickfort`: + - produce a useful error message instead of a code error when a bad query blueprint key sequence leaves the game in a mode that does not have an active cursor + - restore functionality to the ``--verbose`` commandline flag + - don't designate tiles for digging if they are within the bounds of a planned or constructed building + - allow grates, bars, and hatches to be built on flat floor (like DF itself allows) + - allow tracks to be built on hard, natural rock ramps + - allow dig priority to be properly set for track designations + - fix incorrect directions for tracks that extend south or east from a track segment pair specified with expansion syntax (e.g. T(4x4)) + - fix parsing of multi-part extended zone configs (e.g. when you set custom supply limits for hospital zones AND set custom flags for a pond) + - fix error when attempting to set a custom limit for plaster powder in a hospital zone +- `tailor`: fixed some inconsistencies (and possible crashes) when parsing certain subcommands, e.g. ``tailor help`` +- `tiletypes-here`, `tiletypes-here-point`: fix crash when running from an unsuspended core context + +Misc Improvements +----------------- +- Core: DFHack now prints the name of the init script it is running to the console and stderr +- `automaterial`: ensure construction tiles are laid down in order when using `buildingplan` to plan the constructions +- `blueprint`: + - all blueprint phases are now written to a single file, using `quickfort` multi-blueprint file syntax. to get the old behavior of each phase in its own file, pass the ``--splitby=phase`` parameter to ``blueprint`` + - you can now specify the position where the cursor should be when the blueprint is played back with `quickfort` by passing the ``--playback-start`` parameter + - generated blueprints now have labels so `quickfort` can address them by name + - all building types are now supported + - multi-type stockpiles are now supported + - non-rectangular stockpiles and buildings are now supported + - blueprints are no longer generated for phases that have nothing to do (unless those phases are explicitly enabled on the commandline or gui) + - new "track" phase that discovers and records carved tracks + - new "zone" phase that discovers and records activity zones, including custom configuration for ponds, gathering, and hospitals +- `dig-now`: no longer leaves behind a designated tile when a tile was designated beneath a tile designated for channeling +- `gui/blueprint`: + - support the new ``--splitby`` and ``--format`` options for `blueprint` + - hide help text when the screen is too short to display it +- `orders`: added ``list`` subcommand to show existing exported orders +- `quickfort-library-guide`: added light aquifer tap and pump stack blueprints (with step-by-step usage guides) to the quickfort blueprint library +- `quickfort`: + - Dreamfort blueprint set improvements: added iron and flux stock level indicators on the industry level and a prisoner processing quantum stockpile in the surface barracks. also added help text for how to manage sieges and how to manage prisoners after a siege. + - add ``quickfort.apply_blueprint()`` API function that can be called directly by other scripts + - by default, don't designate tiles for digging that have masterwork engravings on them. quality level to preserve is configurable with the new ``--preserve-engravings`` param + - implement single-tile track aliases so engraved tracks can be specified tile-by-tile just like constructed tracks + - allow blueprints to jump up or down multiple z-levels with a single command (e.g. ``#>5`` goes down 5 levels) + - blueprints can now be repeated up and down a specified number of z-levels via ``repeat`` markers in meta blueprints or the ``--repeat`` commandline option + - blueprints can now be rotated, flipped, and shifted via ``transform`` and ``shift`` markers in meta blueprints or the corresponding commandline options +- `quickfort`, `dfhack-examples-guide`: Dreamfort blueprint set improvements based on playtesting and feedback. includes updated profession definitions. + +Removed +------- +- `digfort`: please use `quickfort` instead +- `fortplan`: please use `quickfort` instead + +API +--- +- ``Buildings::findCivzonesAt()``: lookups now complete in constant time instead of linearly scanning through all civzones in the game + +Lua +--- +- ``argparse.processArgsGetopt()``: you can now have long form parameters that are not an alias for a short form parameter. For example, you can now have a parameter like ``--longparam`` without needing to have an equivalent one-letter ``-l`` param. +- ``dwarfmode.enterSidebarMode()``: ``df.ui_sidebar_mode.DesignateMine`` is now a supported target sidebar mode + +Structures +---------- +- ``historical_figure_info.spheres``: give spheres vector a usable name +- ``unit.enemy``: fix definition of ``enemy_status_slot`` and add ``combat_side_id`` + + +DFHack 0.47.05-r3 +================= + +New Plugins +----------- +- `dig-now`: instantly completes dig designations (including smoothing and carving tracks) + +New Scripts +----------- +- `autonick`: gives dwarves unique nicknames +- `build-now`: instantly completes planned building constructions +- `do-job-now`: makes a job involving current selection high priority +- `prioritize`: automatically boosts the priority of current and/or future jobs of specified types, such as hauling food, tanning hides, or pulling levers +- `reveal-adv-map`: exposes/hides all world map tiles in adventure mode + +Fixes +----- +- Core: ``alt`` keydown state is now cleared when DF loses and regains focus, ensuring the ``alt`` modifier state is not stuck on for systems that don't send standard keyup events in response to ``alt-tab`` window manager events +- Lua: ``memscan.field_offset()``: fixed an issue causing `devel/export-dt-ini` to crash sometimes, especially on Windows +- `autofarm`: autofarm will now count plant growths as well as plants toward its thresholds +- `autogems`: no longer assigns gem cutting jobs to workshops with gem cutting prohibited in the workshop profile +- `devel/export-dt-ini`: fixed incorrect vtable address on Windows +- `quickfort`: + - allow machines (e.g. screw pumps) to be built on ramps just like DF allows + - fix error message when the requested label is not found in the blueprint file + +Misc Improvements +----------------- +- `assign-beliefs`, `assign-facets`: now update needs of units that were changed +- `buildingplan`: now displays which items are attached and which items are still missing for planned buildings +- `devel/query`: + - updated script to v3.2 (i.e. major rewrite for maintainability/readability) + - merged options ``-query`` and ``-querykeys`` into ``-search`` + - merged options ``-depth`` and ``-keydepth`` into ``-maxdepth`` + - replaced option ``-safer`` with ``-excludetypes`` and ``-excludekinds`` + - improved how tile data is dealt with identification, iteration, and searching + - added option ``-findvalue`` + - added option ``-showpaths`` to print full data paths instead of nested fields + - added option ``-nopointers`` to disable printing values with memory addresses + - added option ``-alignto`` to set the value column's alignment + - added options ``-oneline`` and alias ``-1`` to avoid using two lines for fields with metadata + - added support for matching multiple patterns + - added support for selecting the highlighted job, plant, building, and map block data + - added support for selecting a Lua script (e.g. `dorf_tables`) + - added support for selecting a Json file (e.g. dwarf_profiles.json) + - removed options ``-listall``, ``-listfields``, and ``-listkeys`` - these are now simply default behaviour + - ``-table`` now accepts the same abbreviations (global names, ``unit``, ``screen``, etc.) as `lua` and `gui/gm-editor` +- `dorf_tables`: integrated `devel/query` to show the table definitions when requested with ``-list`` +- `geld`: fixed ``-help`` option +- `gui/gm-editor`: made search case-insensitive +- `orders`: + - support importing and exporting reaction-specific item conditions, like "lye-containing" for soap production orders + - new ``sort`` command. sorts orders according to their repeat frequency. this prevents daily orders from blocking other orders for similar items from ever getting completed. +- `quickfort`: + - Dreamfort blueprint set improvements: extensive revision based on playtesting and feedback. includes updated ``onMapLoad_dreamfort.init`` settings file, enhanced automation orders, and premade profession definitions. see full changelog at https://github.com/DFHack/dfhack/pull/1921 and https://github.com/DFHack/dfhack/pull/1925 + - accept multiple commands, list numbers, and/or blueprint labels on a single commandline +- `tailor`: allow user to specify which materials to be used, and in what order +- `tiletypes-here`, `tiletypes-here-point`: add ``--cursor`` and ``--quiet`` options to support non-interactive use cases +- `unretire-anyone`: replaced the 'undead' descriptor with 'reanimated' to make it more mod-friendly +- `warn-starving`: added an option to only check sane dwarves + +Documentation +------------- +- `dfhack-examples-guide`: documentation for all of `dreamfort`'s supporting files (useful for all forts, not just Dreamfort!) +- `quickfort-library-guide`: updated dreamfort documentation and added screenshots + +API +--- +- The ``Items`` module ``moveTo*`` and ``remove`` functions now handle projectiles + +Internals +--------- +- Install tests in the scripts repo into hack/scripts/test/scripts when the CMake variable BUILD_TESTS is defined + +Lua +--- +- new global function: ``safe_pairs(iterable[, iterator_fn])`` will iterate over the ``iterable`` (a table or iterable userdata) with the ``iterator_fn`` (``pairs`` if not otherwise specified) if iteration is possible. If iteration is not possible or would throw an error, for example if ``nil`` is passed as the ``iterable``, the iteration is just silently skipped. + +Structures +---------- +- ``cursed_tomb``: new struct type +- ``job_item``: identified several fields +- ``ocean_wave_maker``: new struct type +- ``worldgen_parms``: moved to new struct type + + +DFHack 0.47.05-r2 +================= + +New Scripts +----------- +- `clear-webs`: removes all webs on the map and/or frees any webbed creatures +- `devel/block-borders`: overlay that displays map block borders +- `devel/luacov`: generate code test coverage reports for script development. Define the ``DFHACK_ENABLE_LUACOV=1`` environment variable to start gathering coverage metrics. +- `fix/drop-webs`: causes floating webs to fall to the ground +- `gui/blueprint`: interactive frontend for the `blueprint` plugin (with mouse support!) +- `gui/mass-remove`: mass removal/suspension tool for buildings and constructions +- `reveal-hidden-sites`: exposes all undiscovered sites +- `set-timeskip-duration`: changes the duration of the "Updating World" process preceding the start of a new game, enabling you to jump in earlier or later than usual + +Fixes +----- +- Fixed an issue preventing some external scripts from creating zones and other abstract buildings (see note about room definitions under "Internals") +- Fixed an issue where scrollable text in Lua-based screens could prevent other widgets from scrolling +- `bodyswap`: + - stopped prior party members from tagging along after bodyswapping and reloading the map + - made companions of bodyswapping targets get added to the adventurer party - they can now be viewed using the in-game party system +- `buildingplan`: + - fixed an issue where planned constructions designated with DF's sizing keys (``umkh``) would sometimes be larger than requested + - fixed an issue preventing other plugins like `automaterial` from planning constructions if the "enable all" buildingplan setting was turned on + - made navigation keys work properly in the materials selection screen when alternate keybindings are used +- `color-schemes`: fixed an error in the ``register`` subcommand when the DF path contains certain punctuation characters +- `command-prompt`: fixed issues where overlays created by running certain commands (e.g. `gui/liquids`, `gui/teleport`) would not update the parent screen correctly +- `dwarfvet`: fixed a crash that could occur with hospitals overlapping with other buildings in certain ways +- `embark-assistant`: fixed faulty early exit in first search attempt when searching for waterfalls +- `gui/advfort`: fixed an issue where starting a workshop job while not standing at the center of the workshop required advancing time manually +- `gui/unit-info-viewer`: fixed size description displaying unrelated values instead of size +- `orders`: fixed crash when importing orders with malformed IDs +- `quickfort`: + - comments in blueprint cells no longer prevent the rest of the row from being read. A cell with a single '#' marker in it, though, will still stop the parser from reading further in the row. + - fixed an off-by-one line number accounting in blueprints with implicit ``#dig`` modelines + - changed to properly detect and report an error on sub-alias params with no values instead of just failing to apply the alias later (if you really want an empty value, use ``{Empty}`` instead) + - improved handling of non-rectangular and non-solid extent-based structures (like fancy-shaped stockpiles and farm plots) + - fixed conversion of numbers to DF keycodes in ``#query`` blueprints + - fixed various errors with cropping across the map edge + - properly reset config to default values in ``quickfort reset`` even if if the ``dfhack-config/quickfort/quickfort.txt`` config file doesn't mention all config vars. Also now works even if the config file doesn't exist. +- `stonesense`: fixed a crash that could occur when ctrl+scrolling or closing the Stonesense window +- ``quickfortress.csv`` blueprint: fixed refuse stockpile config and prevented stockpiles from covering stairways + +Misc Improvements +----------------- +- Added adjectives to item selection dialogs, used in tools like `gui/create-item` - this makes it possible to differentiate between different types of high/low boots, shields, etc. (some of which are procedurally generated) +- `blueprint`: + - made ``depth`` and ``name`` parameters optional. ``depth`` now defaults to ``1`` (current level only) and ``name`` defaults to "blueprint" + - ``depth`` can now be negative, which will result in the blueprints being written from the highest z-level to the lowest. Before, blueprints were always written from the lowest z-level to the highest. + - added the ``--cursor`` option to set the starting coordinate for the generated blueprints. A game cursor is no longer necessary if this option is used. +- `devel/annc-monitor`: added ``report enable|disable`` subcommand to filter combat reports +- `embark-assistant`: slightly improved performance of surveying and improved code a little +- `gui/advfort`: added workshop name to workshop UI +- `quickfort`: + - the Dreamfort blueprint set can now be comfortably built in a 1x1 embark + - added the ``--cursor`` option for running a blueprint at specific coordinates instead of starting at the game cursor position + - added more helpful error messages for invalid modeline markers + - added support for extra space characters in blueprints + - added a warning when an invalid alias is encountered instead of silently ignoring it + - made more quiet when the ``--quiet`` parameter is specified +- `setfps`: improved error handling +- `stonesense`: sped up startup time +- `tweak` hide-priority: changed so that priorities stay hidden (or visible) when exiting and re-entering the designations menu +- `unretire-anyone`: the historical figure selection list now includes the ``SYN_NAME`` (necromancer, vampire, etc) of figures where applicable + +Documentation +------------- +- Added more client library implementations to the `remote interface docs ` + +API +--- +- Added ``dfhack.maps.getPlantAtTile(x, y, z)`` and ``dfhack.maps.getPlantAtTile(pos)``, and updated ``dfhack.gui.getSelectedPlant()`` to use it +- Added ``dfhack.units.teleport(unit, pos)`` + +Internals +--------- +- Room definitions and extents are now created for abstract buildings so callers don't have to initialize the room structure themselves +- The DFHack test harness is now much easier to use for iterative development. Configuration can now be specified on the commandline, there are more test filter options, and the test harness can now easily rerun tests that have been run before. +- The ``test/main`` command to invoke the test harness has been renamed to just ``test`` +- Unit tests can now use ``delay_until(predicate_fn, timeout_frames)`` to delay until a condition is met +- Unit tests must now match any output expected to be printed via ``dfhack.printerr()`` +- Unit tests now support fortress mode (allowing tests that require a fortress map to be loaded) - note that these tests are skipped by continuous integration for now, pending a suitable test fortress + +Lua +--- +- new library: ``argparse`` is a collection of commandline argument processing functions +- new string utility functions: + - ``string:wrap(width)`` wraps a string at space-separated word boundaries + - ``string:trim()`` removes whitespace characters from the beginning and end of the string + - ``string:split(delimiter, plain)`` splits a string with the given delimiter and returns a table of substrings. if ``plain`` is specified and set to ``true``, ``delimiter`` is interpreted as a literal string instead of as a pattern (the default) +- new utility function: ``utils.normalizePath()``: normalizes directory slashes across platforms to ``/`` and coalesces adjacent directory separators +- `reveal`: now exposes ``unhideFlood(pos)`` functionality to Lua +- `xlsxreader`: added Lua class wrappers for the xlsxreader plugin API +- ``argparse.processArgsGetopt()`` (previously ``utils.processArgsGetopt()``): + - now returns negative numbers (e.g. ``-10``) in the list of positional parameters instead of treating it as an option string equivalent to ``-1 -0`` + - now properly handles ``--`` like GNU ``getopt`` as a marker to treat all further parameters as non-options + - now detects when required arguments to long-form options are missing +- ``gui.dwarfmode``: new function: ``enterSidebarMode(sidebar_mode, max_esc)`` which uses keypresses to get into the specified sidebar mode from whatever the current screen is +- ``gui.Painter``: fixed error when calling ``viewport()`` method + +Structures +---------- +- Identified remaining rhythm beat enum values +- ``ui_advmode.interactions``: identified some fields related to party members +- ``ui_advmode_menu``: identified several enum items +- ``ui_advmode``: + - identified several fields + - renamed ``wait`` to ``rest_mode`` and changed to an enum with correct values +- ``viewscreen_legendsst.cur_page``: added missing ``Books`` enum item, which fixes some other values + + +DFHack 0.47.05-r1 +================= + +Fixes +----- +- `confirm`: stopped exposing alternate names when convicting units +- `prospector`: improved pre embark rough estimates, particularly for small clusters + +Misc Improvements +----------------- +- `autohauler`: allowed the ``Alchemist`` labor to be enabled in `manipulator` and other labor screens so it can be used for its intended purpose of flagging that no hauling labors should be assigned to a dwarf. Before, the only way to set the flag was to use an external program like Dwarf Therapist. +- `embark-assistant`: slightly improved performance of surveying +- `gui/no-dfhack-init`: clarified how to dismiss dialog that displays when no ``dfhack.init`` file is found +- `quickfort`: + - Dreamfort blueprint set improvements: `significant `_ refinements across the entire blueprint set. Dreamfort is now much faster, much more efficient, and much easier to use. The `checklist `__ now includes a mini-walkthrough for quick reference. The spreadsheet now also includes `embark profile suggestions `__ + - added aliases for configuring masterwork and artifact core quality for all stockpile categories that have them; made it possible to take from multiple stockpiles in the ``quantumstop`` alias + - an active cursor is no longer required for running #notes blueprints (like the dreamfort walkthrough) + - you can now be in any mode with an active cursor when running ``#query`` blueprints (before you could only be in a few "approved" modes, like look, query, or place) + - refined ``#query`` blueprint sanity checks: cursor should still be on target tile at end of configuration, and it's ok for the screen ID to change if you are destroying (or canceling destruction of) a building + - now reports how many work orders were added when generating manager orders from blueprints in the gui dialog + - added ``--dry-run`` option to process blueprints but not change any game state + - you can now specify the number of desired barrels, bins, and wheelbarrows for individual stockpiles when placing them + - ``quickfort orders`` on a ``#place`` blueprint will now enqueue manager orders for barrels, bins, or wheelbarrows that are explicitly set in the blueprint. + - you can now add alias definitions directly to your blueprint files instead of having to put them in a separate aliases.txt file. makes sharing blueprints with custom alias definitions much easier. + +Documentation +------------- +- `digfort`: added deprecation warnings - digfort has been replaced by `quickfort` +- `fortplan`: added deprecation warnings - fortplan has been replaced by `quickfort` + +Structures +---------- +- Identified scattered enum values (some rhythm beats, a couple of corruption unit thoughts, and a few language name categories) +- ``viewscreen_loadgamest``: renamed ``cur_step`` enumeration to match style of ``viewscreen_adopt_regionst`` and ``viewscreen_savegamest`` +- ``viewscreen_savegamest``: identified ``cur_step`` enumeration + + +DFHack 0.47.05-beta1 +==================== + +Fixes +----- +- `embark-assistant`: fixed bug in soil depth determination for ocean tiles +- `orders`: don't crash when importing orders with malformed JSON +- `quickfort`: raw numeric `quickfort-dig-priorities` (e.g. ``3``, which is a valid shorthand for ``d3``) now works when used in .xlsx blueprints + +Misc Improvements +----------------- +- `quickfort`: new commandline options for setting the initial state of the gui dialog. for example: ``quickfort gui -l dreamfort notes`` will start the dialog filtered for the dreamfort walkthrough blueprints + +Structures +---------- +- Dropped support for 0.47.03-0.47.04 + + +DFHack 0.47.04-r5 +================= + +New Scripts +----------- +- `gui/quickfort`: fast access to the quickfort interactive dialog +- `workorder-recheck`: resets the selected work order to the ``Checking`` state + +Fixes +----- +- `embark-assistant`: + - fixed order of factors when calculating min temperature + - improved performance of surveying +- `quickfort`: + - fixed eventual crashes when creating zones + - fixed library aliases for tallow and iron, copper, and steel weapons + - zones are now created in the active state by default + - solve rare crash when changing UI modes +- `search-plugin`: fixed crash when searching the ``k`` sidebar and navigating to another tile with certain keys, like ``<`` or ``>`` +- `seedwatch`: fixed an issue where the plugin would disable itself on map load +- `stockflow`: fixed ``j`` character being intercepted when naming stockpiles +- `stockpiles`: no longer outputs hotkey help text beneath `stockflow` hotkey help text + +Misc Improvements +----------------- +- Lua label widgets (used in all standard message boxes) are now scrollable with Up/Down/PgUp/PgDn keys +- `autofarm`: now fallows farms if all plants have reached the desired count +- `buildingplan`: + - added ability to set global settings from the console, e.g. ``buildingplan set boulders false`` + - added "enable all" option for buildingplan (so you don't have to enable all building types individually). This setting is not persisted (just like quickfort_mode is not persisted), but it can be set from onMapLoad.init + - modified ``Planning Mode`` status in the UI to show whether the plugin is in quickfort mode, "enable all" mode, or whether just the building type is enabled. +- `quickfort`: + - Dreamfort blueprint set improvements: added a streamlined checklist for all required dreamfort commands and gave names to stockpiles, levers, bridges, and zones + - added aliases for bronze weapons and armor + - added alias for tradeable crafts + - new blueprint mode: ``#ignore``, useful for scratch space or personal notes + - implement ``{Empty}`` keycode for use in quickfort aliases; useful for defining blank-by-default alias values + - more flexible commandline parsing allowing for more natural parameter ordering (e.g. where you used to have to write ``quickfort list dreamfort -l`` you can now write ``quickfort list -l dreamfort``) + - print out blueprint names that a ``#meta`` blueprint is applying so it's easier to understand what meta blueprints are doing + - whitespace is now allowed between a marker name and the opening parenthesis in blueprint modelines. for example, ``#dig start (5; 5)`` is now valid (you used to be required to write ``#dig start(5; 5)``) + +Documentation +------------- +- Added documentation for Lua's ``dfhack.run_command()`` and variants + +Lua +--- +- ``dfhack.run_command()``: changed to interface directly with the console when possible, which allows interactive commands and commands that detect the console encoding to work properly +- ``processArgsGetopt()`` added to utils.lua, providing a callback interface for parameter parsing and getopt-like flexibility for parameter ordering and combination (see docs in ``library/lua/utils.lua`` and ``library/lua/3rdparty/alt_getopt.lua`` for details). + +Structures +---------- +- ``job``: identified ``order_id`` field + + +DFHack 0.47.04-r4 +================= + +New Scripts +----------- +- `fix/corrupt-equipment`: fixes some military equipment-related corruption issues that can cause DF crashes + +Fixes +----- +- Fixed an issue on some Linux systems where DFHack installed through a package manager would attempt to write files to a non-writable folder (notably when running `exportlegends` or `gui/autogems`) +- `adaptation`: fixed handling of units with no cave adaptation suffered yet +- `assign-goals`: fixed error preventing new goals from being created +- `assign-preferences`: fixed handling of preferences for flour +- `buildingplan`: + - fixed an issue preventing artifacts from being matched when the maximum item quality is set to ``artifacts`` + - stopped erroneously matching items to buildings while the game is paused + - fixed a crash when pressing 0 while having a noble room selected +- `deathcause`: fixed an error when inspecting certain corpses +- `dwarfmonitor`: fixed a crash when opening the ``prefs`` screen if units have vague preferences +- `dwarfvet`: fixed a crash that could occur when discharging patients +- `embark-assistant`: + - fixed an issue causing incursion resource matching (e.g. sand/clay) to skip some tiles if those resources were provided only through incursions + - corrected river size determination by performing it at the MLT level rather than the world tile level +- `quickfort`: + - fixed handling of modifier keys (e.g. ``{Ctrl}`` or ``{Alt}``) in query blueprints + - fixed misconfiguration of nest boxes, hives, and slabs that were preventing them from being built from build blueprints + - fixed valid placement detection for floor hatches, floor grates, and floor bars (they were erroneously being rejected from open spaces and staircase tops) + - fixed query blueprint statistics being added to the wrong metric when both a query and a zone blueprint are run by the same meta blueprint + - added missing blueprint labels in gui dialog list + - fixed occupancy settings for extent-based structures so that stockpiles can be placed within other stockpiles (e.g. in a checkerboard or bullseye pattern) +- `search-plugin`: fixed an issue where search options might not display if screens were destroyed and recreated programmatically (e.g. with `quickfort`) +- `unsuspend`: now leaves buildingplan-managed buildings alone and doesn't unsuspend underwater tasks +- `workflow`: fixed an error when creating constraints on "mill plants" jobs and some other plant-related jobs +- `zone`: fixed an issue causing the ``enumnick`` subcommand to run when attempting to run ``assign``, ``unassign``, or ``slaughter`` + +Misc Improvements +----------------- +- `buildingplan`: + - added support for all buildings, furniture, and constructions (except for instruments) + - added support for respecting building job_item filters when matching items, so you can set your own programmatic filters for buildings before submitting them to buildingplan + - changed default filter setting for max quality from ``artifact`` to ``masterwork`` + - changed min quality adjustment hotkeys from 'qw' to 'QW' to avoid conflict with existing hotkeys for setting roller speed - also changed max quality adjustment hotkeys from 'QW' to 'AS' to make room for the min quality hotkey changes + - added a new global settings page accessible via the ``G`` hotkey when on any building build screen; ``Quickfort Mode`` toggle for legacy Python Quickfort has been moved to this page + - added new global settings for whether generic building materials should match blocks, boulders, logs, and/or bars - defaults are everything but bars +- `devel/export-dt-ini`: updated for Dwarf Therapist 41.2.0 +- `embark-assistant`: split the lair types displayed on the local map into mound, burrow, and lair +- `gui/advfort`: added support for linking to hatches and pressure plates with mechanisms +- `modtools/add-syndrome`: added support for specifying syndrome IDs instead of names +- `probe`: added more output for designations and tile occupancy +- `quickfort`: + - The Dreamfort sample blueprints now have complete walkthroughs for each fort level and importable orders that automate basic fort stock management + - added more blueprints to the blueprints library: several bedroom layouts, the Saracen Crypts, and the complete fortress example from Python Quickfort: TheQuickFortress + - query blueprint aliases can now accept parameters for dynamic expansion - see dfhack-config/quickfort/aliases.txt for details + - alias names can now include dashes and underscores (in addition to letters and numbers) + - improved speed of first call to ``quickfort list`` significantly, especially for large blueprint libraries + - added ``query_unsafe`` setting to disable query blueprint error checking - useful for query blueprints that send unusual key sequences + - added support for bookcases, display cases, and offering places (altars) + - added configuration support for zone pit/pond, gather, and hospital sub-menus in zone blueprints + - removed ``buildings_use_blocks`` setting and replaced it with more flexible functionality in `buildingplan` + - added support for creating uninitialized stockpiles with :kbd:`c` + +Documentation +------------- +- `quickfort-alias-guide`: alias syntax and alias standard library documentation for `quickfort` blueprints +- `quickfort-library-guide`: overview of the quickfort blueprint library + +API +--- +- `buildingplan`: added Lua interface API +- ``Buildings::setSize()``: changed to reuse existing extents when possible +- ``dfhack.job.isSuitableMaterial()``: added an item type parameter so the ``non_economic`` flag can be properly handled (it was being matched for all item types instead of just boulders) + +Lua +--- +- ``utils.addressof()``: fixed for raw userdata + +Structures +---------- +- ``building_extents_type``: new enum, used for ``building_extents.extents`` +- ``world_mountain_peak``: new struct (was previously inline) - used in ``world_data.mountain_peaks`` + + +DFHack 0.47.04-r3 +================= + +New Plugins +----------- +- `xlsxreader`: provides an API for Lua scripts to read Excel spreadsheets + +New Scripts +----------- +- `quickfort`: DFHack-native implementation of quickfort with many new features and integrations - see the `quickfort-user-guide` for details +- `timestream`: controls the speed of the calendar and creatures +- `uniform-unstick`: prompts units to reevaluate their uniform, by removing/dropping potentially conflicting worn items + +Fixes +----- +- `ban-cooking`: fixed an error in several subcommands +- `buildingplan`: fixed handling of buildings that require buckets +- `getplants`: fixed a crash that could occur on some maps +- `search-plugin`: fixed an issue causing item counts on the trade screen to display inconsistently when searching +- `stockpiles`: + - fixed a crash when loading food stockpiles + - fixed an error when saving furniture stockpiles + +Misc Improvements +----------------- +- `createitem`: + - added support for plant growths (fruit, berries, leaves, etc.) + - added an ``inspect`` subcommand to print the item and material tokens of existing items, which can be used to create additional matching items +- `embark-assistant`: added support for searching for taller waterfalls (up to 50 z-levels tall) +- `search-plugin`: added support for searching for names containing non-ASCII characters using their ASCII equivalents +- `stocks`: added support for searching for items containing non-ASCII characters using their ASCII equivalents +- `unretire-anyone`: made undead creature names appear in the historical figure list +- `zone`: + - added an ``enumnick`` subcommand to assign enumerated nicknames (e.g "Hen 1", "Hen 2"...) + - added slaughter indication to ``uinfo`` output + +Documentation +------------- +- Fixed syntax highlighting of most code blocks to use the appropriate language (or no language) instead of Python + +API +--- +- Added ``DFHack::to_search_normalized()`` (Lua: ``dfhack.toSearchNormalized()``) to convert non-ASCII alphabetic characters to their ASCII equivalents + +Structures +---------- +- ``history_event_masterpiece_createdst``: fixed alignment, including subclasses, and identified ``skill_at_time`` +- ``item_body_component``: fixed some alignment issues and identified some fields (also applies to subclasses like ``item_corpsest``) +- ``stockpile_settings``: removed ``furniture.sand_bags`` (no longer present) + + +DFHack 0.47.04-r2 +================= + +New Scripts +----------- +- `animal-control`: helps manage the butchery and gelding of animals +- `devel/kill-hf`: kills a historical figure +- `geld`: gelds or ungelds animals +- `list-agreements`: lists all guildhall and temple agreements +- `list-waves`: displays migration wave information for citizens/units +- `ungeld`: ungelds animals (wrapper around `geld`) + +New Tweaks +---------- +- `tweak` do-job-now: adds a job priority toggle to the jobs list +- `tweak` reaction-gloves: adds an option to make reactions produce gloves in sets with correct handedness + +Fixes +----- +- Fixed a segfault when attempting to start a headless session with a graphical PRINT_MODE setting +- Fixed an issue with the macOS launcher failing to un-quarantine some files +- Fixed ``Units::isEggLayer``, ``Units::isGrazer``, ``Units::isMilkable``, ``Units::isTrainableHunting``, ``Units::isTrainableWar``, and ``Units::isTamable`` ignoring the unit's caste +- Linux: fixed ``dfhack.getDFPath()`` (Lua) and ``Process::getPath()`` (C++) to always return the DF root path, even if the working directory has changed +- `digfort`: + - fixed y-line tracking when .csv files contain lines with only commas + - fixed an issue causing blueprints touching the southern or eastern edges of the map to be rejected (northern and western edges were already allowed). This allows blueprints that span the entire embark area. +- `embark-assistant`: fixed a couple of incursion handling bugs. +- `embark-skills`: fixed an issue with structures causing the ``points`` option to do nothing +- `exportlegends`: + - fixed an issue where two different ```` tags could be included in a ```` + - stopped including some tags with ``-1`` values which don't provide useful information +- `getplants`: fixed issues causing plants to be collected even if they have no growths (or unripe growths) +- `gui/advfort`: fixed "operate pump" job +- `gui/load-screen`: fixed an issue causing longer timezones to be cut off +- `labormanager`: + - fixed handling of new jobs in 0.47 + - fixed an issue preventing custom furnaces from being built +- `modtools/moddable-gods`: + - fixed an error when creating the historical figure + - removed unused ``-domain`` and ``-description`` arguments + - made ``-depictedAs`` argument work +- `names`: + - fixed an error preventing the script from working + - fixed an issue causing renamed units to display their old name in legends mode and some other places +- `pref-adjust`: fixed some compatibility issues and a potential crash +- `RemoteFortressReader`: + - fixed a couple crashes that could result from decoding invalid enum items (``site_realization_building_type`` and ``improvement_type``) + - fixed an issue that could cause block coordinates to be incorrect +- `rendermax`: fixed a hang that could occur when enabling some renderers, notably on Linux +- `stonesense`: + - fixed a crash when launching Stonesense + - fixed some issues that could cause the splash screen to hang + +Misc Improvements +----------------- +- Linux/macOS: Added console keybindings for deleting words (Alt+Backspace and Alt+d in most terminals) +- `add-recipe`: + - added tool recipes (minecarts, wheelbarrows, stepladders, etc.) + - added a command explanation or error message when entering an invalid command +- `armoks-blessing`: added adjustments to values and needs +- `blueprint`: + - now writes blueprints to the ``blueprints/`` subfolder instead of the df root folder + - now automatically creates folder trees when organizing blueprints into subfolders (e.g. ``blueprint 30 30 1 rooms/dining dig`` will create the file ``blueprints/rooms/dining-dig.csv``); previously it would fail if the ``blueprints/rooms/`` directory didn't already exist +- `confirm`: added a confirmation dialog for convicting dwarves of crimes +- `devel/query`: added many new query options +- `digfort`: + - handled double quotes (") at the start of a string, allowing .csv files exported from spreadsheets to work without manual modification + - documented that removing ramps, cutting trees, and gathering plants are indeed supported + - added a ``force`` option to truncate blueprints if the full blueprint would extend off the edge of the map +- `dwarf-op`: + - added ability to select dwarves based on migration wave + - added ability to protect dwarves based on symbols in their custom professions +- `exportlegends`: + - changed some flags to be represented by self-closing tags instead of true/false strings (e.g. ````) - note that this may require changes to other XML-parsing utilities + - changed some enum values from numbers to their string representations + - added ability to save all files to a subfolder, named after the region folder and date by default +- `gui/advfort`: added support for specifying the entity used to determine available resources +- `gui/gm-editor`: added support for automatically following ref-targets when pressing the ``i`` key +- `manipulator`: added a new column option to display units' goals +- `modtools/moddable-gods`: added support for ``neuter`` gender +- `pref-adjust`: + - added support for adjusting just the selected dwarf + - added a new ``goth`` profile +- `remove-stress`: added a ``-value`` argument to enable setting stress level directly +- `workorder`: changed default frequency from "Daily" to "OneTime" + +Documentation +------------- +- Added some new dev-facing pages, including dedicated pages about the remote API, memory research, and documentation +- Expanded the installation guide +- Made a couple theme adjustments + +API +--- +- Added ``Filesystem::mkdir_recursive`` +- Extended ``Filesystem::listdir_recursive`` to optionally make returned filenames relative to the start directory +- ``Units``: added goal-related functions: ``getGoalType()``, ``getGoalName()``, ``isGoalAchieved()`` + +Internals +--------- +- Added support for splitting scripts into multiple files in the ``scripts/internal`` folder without polluting the output of `ls` + +Lua +--- +- Added a ``ref_target`` field to primitive field references, corresponding to the ``ref-target`` XML attribute +- Made ``dfhack.units.getRaceNameById()``, ``dfhack.units.getRaceBabyNameById()``, and ``dfhack.units.getRaceChildNameById()`` available to Lua + +Ruby +---- +- Updated ``item_find`` and ``building_find`` to use centralized logic that works on more screens + +Structures +---------- +- Added a new ````, which allows ``world.*.other`` collections of vectors to use the correct subtypes for items +- ``creature_raw``: renamed ``gender`` to ``sex`` to match the field in ``unit``, which is more frequently used +- ``crime``: identified ``witnesses``, which contains the data held by the old field named ``reports`` +- ``intrigue``: new type (split out from ``historical_figure_relationships``) +- ``items_other_id``: removed ``BAD``, and by extension, ``world.items.other.BAD``, which was overlapping with ``world.items.bad`` +- ``job_type``: added job types new to 0.47 +- ``plant_raw``: material_defs now contains arrays rather than loose fields +- ``pronoun_type``: new enum (previously documented in field comments) +- ``setup_character_info``: fixed a couple alignment issues (needed by `embark-skills`) +- ``ui_advmode_menu``: identified some new enum items + + +DFHack 0.47.04-r1 +================= + +Fixes +----- +- Fixed a crash in ``find()`` for some types when no world is loaded +- Fixed translation of certain types of in-game names +- `autogems`: fixed an issue with binned gems being ignored in linked stockpiles +- `catsplosion`: fixed error when handling races with only one caste (e.g. harpies) +- `exportlegends`: fixed error when exporting maps +- `spawnunit`: fixed an error when forwarding some arguments but not a location to `modtools/create-unit` +- `stocks`: fixed display of book titles +- `tweak` embark-profile-name: fixed handling of the native shift+space key + +Misc Improvements +----------------- +- `exportlegends`: + - made interaction export more robust and human-readable + - removed empty ```` and ```` tags +- `getplants`: added switches for designations for farming seeds and for max number designated per plant +- `manipulator`: added intrigue to displayed skills +- `modtools/create-unit`: + - added ``-equip`` option to equip created units + - added ``-skills`` option to give skills to units + - added ``-profession`` and ``-customProfession`` options to adjust unit professions +- `search-plugin`: added support for the fortress mode justice screen +- ``dfhack.init-example``: enabled `autodump` + +API +--- +- Added ``Items::getBookTitle`` to get titles of books. Catches titles buried in improvements, unlike getDescription. + +Lua +--- +- ``pairs()`` now returns available class methods for DF types + +Structures +---------- +- Added globals: ``cur_rain``, ``cur_rain_counter``, ``cur_snow``, ``cur_snow_counter``, ``weathertimer``, ``jobvalue``, ``jobvalue_setter``, ``interactitem``, ``interactinvslot``, ``handleannounce``, ``preserveannounce``, ``updatelightstate`` +- ``agreement_details_data_plot_sabotage``: new struct type, along with related ``agreement_details_type.PlotSabotage`` +- ``architectural_element``: new enum +- ``battlefield``: new struct type +- ``breed``: new struct type +- ``creature_handler``: identified vmethods +- ``crime``: removed fields of ``reports`` that are no longer present +- ``dance_form``: identified most fields +- ``history_event_context``: identified fields +- ``identity_type``: new enum +- ``identity``: renamed ``civ`` to ``entity_id``, identified ``type`` +- ``image_set``: new struct type +- ``interrogation_report``: new struct type +- ``itemdef_flags``: new enum, with ``GENERATED`` flag +- ``justification``: new enum +- ``lever_target_type``: identified ``LeverMechanism`` and ``TargetMechanism`` values +- ``musical_form``: identified fields, including some renames. Also identified fields in ``scale`` and ``rhythm`` +- ``region_weather``: new struct type +- ``squad_order_cause_trouble_for_entityst``: identified fields +- ``unit_thought_type``: added several new thought types +- ``viewscreen_workquota_detailsst``: identified fields + + +DFHack 0.47.04-beta1 +==================== + +New Scripts +----------- +- `color-schemes`: manages color schemes +- `devel/print-event`: prints the description of an event by ID or index +- `gui/color-schemes`: an in-game interface for `color-schemes` +- `light-aquifers-only`: changes heavy aquifers to light aquifers +- `on-new-fortress`: runs DFHack commands only in a new fortress +- `once-per-save`: runs DFHack commands unless already run in the current save +- `resurrect-adv`: brings your adventurer back to life +- `reveal-hidden-units`: exposes all sneaking units +- `workorder`: allows queuing manager jobs; smart about shear and milk creature jobs + +Fixes +----- +- Fixed a crash when starting DFHack in headless mode with no terminal +- `devel/visualize-structure`: fixed padding detection for globals +- `exportlegends`: + - added UTF-8 encoding and XML escaping for more fields + - added checking for unhandled structures to avoid generating invalid XML + - fixed missing fields in ``history_event_assume_identityst`` export +- `full-heal`: + - when resurrected by specifying a corpse, units now appear at the location of the corpse rather than their location of death + - resurrected units now have their tile occupancy set (and are placed in the prone position to facilitate this) + +Misc Improvements +----------------- +- Added "bit" suffix to downloads (e.g. 64-bit) +- Tests: + - moved from DF folder to hack/scripts folder, and disabled installation by default + - made test runner script more flexible +- `devel/export-dt-ini`: updated some field names for DT for 0.47 +- `devel/visualize-structure`: added human-readable lengths to containers +- `dfhack-run`: added color output support +- `embark-assistant`: + - updated embark aquifer info to show all aquifer kinds present + - added neighbor display, including kobolds (SKULKING) and necro tower count + - updated aquifer search criteria to handle the new variation + - added search criteria for embark initial tree cover + - added search criteria for necro tower count, neighbor civ count, and specific neighbors. Should handle additional entities, but not tested +- `exportlegends`: + - added evilness and force IDs to regions + - added profession and weapon info to relevant entities + - added support for many new history events in 0.47 + - added historical event relationships and supplementary data +- `full-heal`: + - made resurrection produce a historical event viewable in Legends mode + - made error messages more explanatory +- `install-info`: added DFHack build ID to report +- `modtools/create-item`: added ``-matchingGloves`` and ``-matchingShoes`` arguments +- `modtools/create-unit`: + - added ``-duration`` argument to make the unit vanish after some time + - added ``-locationRange`` argument to allow spawning in a random position within a defined area + - added ``-locationType`` argument to specify the type of location to spawn in +- `unretire-anyone`: added ``-dead`` argument to revive and enable selection of a dead historical figure to use as an adventurer in adv mode + +Internals +--------- +- Added separate changelogs in the scripts and df-structures repos +- Improved support for tagged unions, allowing tools to access union fields more safely +- Moved ``reversing`` scripts to df_misc repo + +Structures +---------- +- Added an XML schema for validating df-structures syntax +- Added ``divination_set_next_id`` and ``image_set_next_id`` globals +- ``activity_entry_type``: new enum type +- ``adventure_optionst``: identified many vmethods +- ``agreement_details``: identified most fields of most sub-structs +- ``artifact_claim``: identified several fields +- ``artifact_record``: identified several fields +- ``caste_raw_flags``: renamed and identified many flags to match information from Toady +- ``creature_raw_flags``: renamed and identified many flags to match information from Toady +- ``crime_type``: new enum type +- ``dfhack_room_quality_level``: added enum attributes for names of rooms of each quality +- ``entity_site_link_type``: new enum type +- ``export_map_type``: new enum type +- ``historical_entity.flags``: identified several flags +- ``historical_entity.relations``: renamed from ``unknown1b`` and identified several fields +- ``historical_figure.vague_relationships``: identified +- ``historical_figure_info.known_info``: renamed from ``secret``, identified some fields +- ``historical_figure``: renamed ``unit_id2`` to ``nemesis_id`` +- ``history_event_circumstance_info``: new struct type (and changed several ``history_event`` subclasses to use this) +- ``history_event_reason_info``: new struct type (and changed several ``history_event`` subclasses to use this) +- ``honors_type``: identified several fields +- ``interaction_effect_create_itemst``: new struct type +- ``interaction_effect_summon_unitst``: new struct type +- ``item``: identified several vmethods +- ``layer_type``: new enum type +- ``plant.damage_flags``: added ``is_dead`` +- ``plot_role_type``: new enum type +- ``plot_strategy_type``: new enum type +- ``relationship_event_supplement``: new struct type +- ``relationship_event``: new struct type +- ``specific_ref``: moved union data to ``data`` field +- ``ui_look_list``: moved union fields to ``data`` and renamed to match ``type`` enum +- ``ui_sidebar_menus.location``: added new profession-related fields, renamed and fixed types of deity-related fields +- ``ui_sidebar_mode``: added ``ZonesLocationInfo`` +- ``unit_action``: rearranged as tagged union with new sub-types; existing code should be compatible +- ``vague_relationship_type``: new enum type +- ``vermin_flags``: identified ``is_roaming_colony`` +- ``viewscreen_justicest``: identified interrogation-related fields +- ``world_data.field_battles``: identified and named several fields + + +DFHack 0.47.03-beta1 +==================== + +New Scripts +----------- +- `devel/sc`: checks size of structures +- `devel/visualize-structure`: displays the raw memory of a structure + +Fixes +----- +- `adv-max-skills`: fixed for 0.47 +- `deep-embark`: + - prevented running in non-fortress modes + - ensured that only the newest wagon is deconstructed +- `full-heal`: + - fixed issues with removing corpses + - fixed resurrection for non-historical figures +- `modtools/create-unit`: added handling for arena tame setting +- `teleport`: fixed setting new tile occupancy + +Misc Improvements +----------------- +- `deep-embark`: + - improved support for using directly from the DFHack console + - added a ``-clear`` option to cancel +- `exportlegends`: + - added identity information + - added creature raw names and flags +- `gui/prerelease-warning`: updated links and information about nightly builds +- `modtools/syndrome-trigger`: enabled simultaneous use of ``-synclass`` and ``-syndrome`` +- `repeat`: added ``-list`` option + +Structures +---------- +- Dropped support for 0.44.12-0.47.02 +- ``abstract_building_type``: added types (and subclasses) new to 0.47 +- ``agreement_details_type``: added enum +- ``agreement_details``: added struct type (and many associated data types) +- ``agreement_party``: added struct type +- ``announcement_type``: added types new to 0.47 +- ``artifact_claim_type``: added enum +- ``artifact_claim``: added struct type +- ``breath_attack_type``: added ``SHARP_ROCK`` +- ``building_offering_placest``: new class +- ``building_type``: added ``OfferingPlace`` +- ``caste_raw_flags``: renamed many items to match DF names +- ``creature_interaction_effect``: added subclasses new to 0.47 +- ``creature_raw_flags``: + - identified several more items + - renamed many items to match DF names +- ``d_init``: added settings new to 0.47 +- ``entity_name_type``: added ``MERCHANT_COMPANY``, ``CRAFT_GUILD`` +- ``entity_position_responsibility``: added values new to 0.47 +- ``fortress_type``: added enum +- ``general_ref_type``: added ``UNIT_INTERROGATEE`` +- ``ghost_type``: added ``None`` value +- ``goal_type``: added goals types new to 0.47 +- ``histfig_site_link``: added subclasses new to 0.47 +- ``history_event_collection``: added subtypes new to 0.47 +- ``history_event_context``: added lots of new fields +- ``history_event_reason``: + - added captions for all items + - added items new to 0.47 +- ``history_event_type``: added types for events new to 0.47, as well as corresponding ``history_event`` subclasses (too many to list here) +- ``honors_type``: added struct type +- ``interaction_effect``: added subtypes new to 0.47 +- ``interaction_source_experimentst``: added class type +- ``interaction_source_usage_hint``: added values new to 0.47 +- ``interface_key``: added items for keys new to 0.47 +- ``job_skill``: added ``INTRIGUE``, ``RIDING`` +- ``lair_type``: added enum +- ``monument_type``: added enum +- ``next_global_id``: added enum +- ``poetic_form_action``: added ``Beseech`` +- ``setup_character_info``: expanded significantly in 0.47 +- ``text_system``: added layout for struct +- ``tile_occupancy``: added ``varied_heavy_aquifer`` +- ``tool_uses``: added items: ``PLACE_OFFERING``, ``DIVINATION``, ``GAMES_OF_CHANCE`` +- ``viewscreen_counterintelligencest``: new class (only layout identified so far) + + +DFHack 0.44.12-r3 +================= + +New Plugins +----------- +- `autoclothing`: automatically manage clothing work orders +- `autofarm`: replaces the previous Ruby script of the same name, with some fixes +- `map-render`: allows programmatically rendering sections of the map that are off-screen +- `tailor`: automatically manages keeping your dorfs clothed + +New Scripts +----------- +- `assign-attributes`: changes the attributes of a unit +- `assign-beliefs`: changes the beliefs of a unit +- `assign-facets`: changes the facets (traits) of a unit +- `assign-goals`: changes the goals of a unit +- `assign-preferences`: changes the preferences of a unit +- `assign-profile`: sets a dwarf's characteristics according to a predefined profile +- `assign-skills`: changes the skills of a unit +- `combat-harden`: sets a unit's combat-hardened value to a given percent +- `deep-embark`: allows embarking underground +- `devel/find-twbt`: finds a TWBT-related offset needed by the new `map-render` plugin +- `dwarf-op`: optimizes dwarves for fort-mode work; makes managing labors easier +- `forget-dead-body`: removes emotions associated with seeing a dead body +- `gui/create-tree`: creates a tree at the selected tile +- `linger`: takes over your killer in adventure mode +- `modtools/create-tree`: creates a tree +- `modtools/pref-edit`: add, remove, or edit the preferences of a unit +- `modtools/set-belief`: changes the beliefs (values) of units +- `modtools/set-need`: sets and edits unit needs +- `modtools/set-personality`: changes the personality of units +- `modtools/spawn-liquid`: spawns water or lava at the specified coordinates +- `set-orientation`: edits a unit's orientation +- `unretire-anyone`: turns any historical figure into a playable adventurer + +Fixes +----- +- Fixed a crash in the macOS/Linux console when the prompt was wider than the screen width +- Fixed inconsistent results from ``Units::isGay`` for asexual units +- Fixed some cases where Lua filtered lists would not properly intercept keys, potentially triggering other actions on the same screen +- `autofarm`: + - fixed biome detection to properly determine crop assignments on surface farms + - reimplemented as a C++ plugin to make proper biome detection possible +- `bodyswap`: fixed companion list not being updated often enough +- `cxxrandom`: removed some extraneous debug information +- `digfort`: now accounts for z-level changes when calculating maximum y dimension +- `embark-assistant`: + - fixed bug causing crash on worlds without generated metals (as well as pruning vectors as originally intended). + - fixed bug causing mineral matching to fail to cut off at the magma sea, reporting presence of things that aren't (like DF does currently). + - fixed bug causing half of the river tiles not to be recognized. + - added logic to detect some river tiles DF doesn't generate data for (but are definitely present). +- `eventful`: fixed invalid building ID in some building events +- `exportlegends`: now escapes special characters in names properly +- `getplants`: fixed designation of plants out of season (note that picked plants are still designated incorrectly) +- `gui/autogems`: fixed error when no world is loaded +- `gui/companion-order`: + - fixed error when resetting group leaders + - ``leave`` now properly removes companion links +- `gui/create-item`: fixed module support - can now be used from other scripts +- `gui/stamper`: + - stopped "invert" from resetting the designation type + - switched to using DF's designation keybindings instead of custom bindings + - fixed some typos and text overlapping +- `modtools/create-unit`: + - fixed an error associating historical entities with units + - stopped recalculating health to avoid newly-created citizens triggering a "recover wounded" job + - fixed units created in arena mode having blank names + - fixed units created in arena mode having the wrong race and/or interaction effects applied after creating units manually in-game + - stopped units from spawning with extra items or skills previously selected in the arena + - stopped setting some unneeded flags that could result in glowing creature tiles + - set units created in adventure mode to have no family, instead of being related to the first creature in the world +- `modtools/reaction-product-trigger`: + - fixed an error dealing with reactions in adventure mode + - blocked ``\\BUILDING_ID`` for adventure mode reactions + - fixed ``-clear`` to work without passing other unneeded arguments +- `modtools/reaction-trigger`: + - fixed a bug when determining whether a command was run + - fixed handling of ``-resetPolicy`` +- `mousequery`: fixed calculation of map dimensions, which was sometimes preventing scrolling the map with the mouse when TWBT was enabled +- `RemoteFortressReader`: fixed a crash when a unit's path has a length of 0 +- `stonesense`: fixed crash due to wagons and other soul-less creatures +- `tame`: now sets the civ ID of tamed animals (fixes compatibility with `autobutcher`) +- `title-folder`: silenced error when ``PRINT_MODE`` is set to ``TEXT`` + +Misc Improvements +----------------- +- Added a note to `dfhack-run` when called with no arguments (which is usually unintentional) +- On macOS, the launcher now attempts to un-quarantine the rest of DFHack +- `bodyswap`: added arena mode support +- `combine-drinks`: added more default output, similar to `combine-plants` +- `createitem`: added a list of valid castes to the "invalid caste" error message, for convenience +- `devel/export-dt-ini`: added more size information needed by newer Dwarf Therapist versions +- `dwarfmonitor`: enabled widgets to access other scripts and plugins by switching to the core Lua context +- `embark-assistant`: + - added an in-game option to activate on the embark screen + - changed waterfall detection to look for level drop rather than just presence + - changed matching to take incursions, i.e. parts of other biomes, into consideration when evaluating tiles. This allows for e.g. finding multiple biomes on single tile embarks. + - changed overlay display to show when incursion surveying is incomplete + - changed overlay display to show evil weather + - added optional parameter "fileresult" for crude external harness automated match support + - improved focus movement logic to go to only required world tiles, increasing speed of subsequent searches considerably +- `exportlegends`: added rivers to custom XML export +- `exterminate`: added support for a special ``enemy`` caste +- `gui/gm-unit`: + - added support for editing: + - added attribute editor + - added orientation editor + - added editor for bodies and body parts + - added color editor + - added belief editor + - added personality editor +- `modtools/create-item`: documented already-existing ``-quality`` option +- `modtools/create-unit`: + - added the ability to specify ``\\LOCAL`` for the fort group entity + - now enables the default labours for adult units with CAN_LEARN. + - now sets historical figure orientation. + - improved speed of creating multiple units at once + - made the script usable as a module (from other scripts) +- `modtools/reaction-trigger`: + - added ``-ignoreWorker``: ignores the worker when selecting the targets + - changed the default behavior to skip inactive/dead units; added ``-dontSkipInactive`` to include creatures that are inactive + - added ``-range``: controls how far eligible targets can be from the workshop + - syndromes now are applied before commands are run, not after + - if both a command and a syndrome are given, the command only runs if the syndrome could be applied +- `mousequery`: made it more clear when features are enabled +- `RemoteFortressReader`: + - added a basic framework for controlling and reading the menus in DF (currently only supports the building menu) + - added support for reading item raws + - added a check for whether or not the game is currently saving or loading, for utilities to check if it's safe to read from DF + - added unit facing direction estimate and position within tiles + - added unit age + - added unit wounds + - added tree information + - added check for units' current jobs when calculating the direction they are facing + +API +--- +- Added new ``plugin_load_data`` and ``plugin_save_data`` events for plugins to load/save persistent data +- Added ``Maps::GetBiomeType`` and ``Maps::GetBiomeTypeByRef`` to infer biome types properly +- Added ``Units::getPhysicalDescription`` (note that this depends on the ``unit_get_physical_description`` offset, which is not yet available for all DF builds) + +Internals +--------- +- Added new Persistence module +- Cut down on internal DFHack dependencies to improve build times +- Improved concurrency in event and server handlers +- Persistent data is now stored in JSON files instead of historical figures - existing data will be migrated when saving +- `stonesense`: fixed some OpenGL build issues on Linux + +Lua +--- +- Exposed ``gui.dwarfmode.get_movement_delta`` and ``gui.dwarfmode.get_hotkey_target`` +- ``dfhack.run_command`` now returns the command's return code + +Ruby +---- +- Made ``unit_ishostile`` consistently return a boolean + +Structures +---------- +- Added ``unit_get_physical_description`` function offset on some platforms +- Added/identified types: + - ``assume_identity_mode`` + - ``musical_form_purpose`` + - ``musical_form_style`` + - ``musical_form_pitch_style`` + - ``musical_form_feature`` + - ``musical_form_vocals`` + - ``musical_form_melodies`` + - ``musical_form_interval`` + - ``unit_emotion_memory`` +- ``need_type``: fixed ``PrayOrMeditate`` typo +- ``personality_facet_type``, ``value_type``: added ``NONE`` values +- ``twbt_render_map``: added for 64-bit 0.44.12 (for `map-render`) + + +DFHack 0.44.12-r2 +================= + +New Plugins +----------- +- `debug`: manages runtime debug print category filtering +- `nestboxes`: automatically scan for and forbid fertile eggs incubating in a nestbox + +New Scripts +----------- +- `devel/query`: searches for field names in DF objects +- `extinguish`: puts out fires +- `tame`: sets tamed/trained status of animals + +Fixes +----- +- `building-hacks`: fixed error when dealing with custom animation tables +- `devel/test-perlin`: fixed Lua error (``math.pow()``) +- `embark-assistant`: fixed crash when entering finder with a 16x16 embark selected, and added 16 to dimension choices +- `embark-skills`: fixed missing ``skill_points_remaining`` field +- `full-heal`: + - stopped wagon resurrection + - fixed a minor issue with post-resurrection hostility +- `gui/companion-order`: + - fixed issues with printing coordinates + - fixed issues with move command + - fixed cheat commands (and removed "Power up", which was broken) +- `gui/gm-editor`: fixed reinterpret cast (``r``) +- `gui/pathable`: fixed error when sidebar is hidden with ``Tab`` +- `labormanager`: + - stopped assigning labors to ineligible dwarves, pets, etc. + - stopped assigning invalid labors + - added support for crafting jobs that use pearl + - fixed issues causing cleaning jobs to not be assigned + - added support for disabling management of specific labors +- `prospector`: (also affected `embark-tools`) - fixed a crash when prospecting an unusable site (ocean, mountains, etc.) with a large default embark size in d_init.txt (e.g. 16x16) +- `siege-engine`: fixed a few Lua errors (``math.pow()``, ``unit.relationship_ids``) +- `tweak`: fixed ``hotkey-clear`` + +Misc Improvements +----------------- +- `armoks-blessing`: improved documentation to list all available arguments +- `devel/export-dt-ini`: + - added viewscreen offsets for DT 40.1.2 + - added item base flags offset + - added needs offsets +- `embark-assistant`: + - added match indicator display on the right ("World") map + - changed 'c'ancel to abort find if it's under way and clear results if not, allowing use of partial surveys. + - added Coal as a search criterion, as well as a coal indication as current embark selection info. +- `full-heal`: + - added ``-all``, ``-all_civ`` and ``-all_citizens`` arguments + - added module support + - now removes historical figure death dates and ghost data +- `growcrops`: added ``all`` argument to grow all crops +- `gui/load-screen`: improved documentation +- `labormanager`: now takes nature value into account when assigning jobs +- `open-legends`: added warning about risk of save corruption and improved related documentation +- `points`: added support when in ``viewscreen_setupdwarfgamest`` and improved error messages +- `siren`: removed break handling (relevant ``misc_trait_type`` was no longer used - see "Structures" section) + +API +--- +- New debug features related to `debug` plugin: + - Classes (C++ only): ``Signal``, ``DebugCategory``, ``DebugManager`` + - Macros: ``TRACE``, ``DEBUG``, ``INFO``, ``WARN``, ``ERR``, ``DBG_DECLARE``, ``DBG_EXTERN`` + +Internals +--------- +- Added a usable unit test framework for basic tests, and a few basic tests +- Added ``CMakeSettings.json`` with intellisense support +- Changed ``plugins/CMakeLists.custom.txt`` to be ignored by git and created (if needed) at build time instead +- Core: various thread safety and memory management improvements +- Fixed CMake build dependencies for generated header files +- Fixed custom ``CMAKE_CXX_FLAGS`` not being passed to plugins +- Linux/macOS: changed recommended build backend from Make to Ninja (Make builds will be significantly slower now) + +Lua +--- +- ``utils``: new ``OrderedTable`` class + +Structures +---------- +- Win32: added missing vtables for ``viewscreen_storesst`` and ``squad_order_rescue_hfst`` +- ``activity_event_performancest``: renamed poem as written_content_id +- ``body_part_status``: identified ``gelded`` +- ``dance_form``: named musical_form_id and musical_written_content_id +- ``incident_sub6_performance.participants``: named performance_event and role_index +- ``incident_sub6_performance``: + - made performance_event an enum + - named poetic_form_id, musical_form_id, and dance_form_id +- ``misc_trait_type``: removed ``LikesOutdoors``, ``Hardened``, ``TimeSinceBreak``, ``OnBreak`` (all unused by DF) +- ``musical_form_instruments``: named minimum_required and maximum_permitted +- ``musical_form``: named voices field +- ``plant_tree_info``: identified ``extent_east``, etc. +- ``plant_tree_tile``: gave connection bits more meaningful names (e.g. ``connection_east`` instead of ``thick_branches_1``) +- ``poetic_form``: identified many fields and related enum/bitfield types +- ``setup_character_info``: identified ``skill_points_remaining`` (for `embark-skills`) +- ``ui.main``: identified ``fortress_site`` +- ``ui.squads``: identified ``kill_rect_targets_scroll`` +- ``ui``: fixed alignment of ``main`` and ``squads`` (fixes `tweak` hotkey-clear and DF-AI) +- ``unit_action.attack``: + - identified ``attack_skill`` + - added ``lightly_tap`` and ``spar_report`` flags +- ``unit_flags3``: identified ``marked_for_gelding`` +- ``unit_personality``: identified ``stress_drain``, ``stress_boost``, ``likes_outdoors``, ``combat_hardened`` +- ``unit_storage_status``: newly identified type, stores noble holdings information (used in ``viewscreen_layer_noblelistst``) +- ``unit_thought_type``: added new expulsion thoughts from 0.44.12 +- ``viewscreen_layer_arena_creaturest``: identified item- and name-related fields +- ``viewscreen_layer_militaryst``: identified ``equip.assigned.assigned_items`` +- ``viewscreen_layer_noblelistst``: identified ``storage_status`` (see ``unit_storage_status`` type) +- ``viewscreen_new_regionst``: + - identified ``rejection_msg``, ``raw_folder``, ``load_world_params`` + - changed many ``int8_t`` fields to ``bool`` +- ``viewscreen_setupadventurest``: identified some nemesis and personality fields, and ``page.ChooseHistfig`` +- ``world_data``: added ``mountain_peak_flags`` type, including ``is_volcano`` +- ``world_history``: identified names and/or types of some fields +- ``world_site``: identified names and/or types of some fields +- ``written_content``: named poetic_form + + +DFHack 0.44.12-r1 +================= + +Fixes +----- +- Console: fixed crash when entering long commands on Linux/macOS +- Fixed special characters in `command-prompt` and other non-console in-game outputs on Linux/macOS (in tools using ``df2console``) +- Removed jsoncpp's ``include`` and ``lib`` folders from DFHack builds/packages +- `die`: fixed Windows crash in exit handling +- `dwarfmonitor`, `manipulator`: fixed stress cutoffs +- `modtools/force`: fixed a bug where the help text would always be displayed and nothing useful would happen +- `ruby`: fixed calling conventions for vmethods that return strings (currently ``enabler.GetKeyDisplay()``) +- `startdwarf`: fixed on 64-bit Linux + +Misc Improvements +----------------- +- Reduced time for designation jobs from tools like `digv` to be assigned workers +- `embark-assistant`: + - Switched to standard scrolling keys, improved spacing slightly + - Introduced scrolling of Finder search criteria, removing requirement for 46 lines to work properly (Help/Info still formatted for 46 lines). + - Added Freezing search criterion, allowing searches for NA/Frozen/At_Least_Partial/Partial/At_Most_Partial/Never Freezing embarks. +- `rejuvenate`: + - Added ``-all`` argument to apply to all citizens + - Added ``-force`` to include units under 20 years old + - Clarified documentation + +API +--- +- Added to ``Units`` module: + - ``getStressCategory(unit)`` + - ``getStressCategoryRaw(level)`` + - ``stress_cutoffs`` (Lua: ``getStressCutoffs()``) + +Internals +--------- +- Added documentation for all RPC functions and a build-time check +- Added support for build IDs to development builds +- Changed default build architecture to 64-bit +- Use ``dlsym(3)`` to find vtables from libgraphics.so + +Structures +---------- +- Added ``start_dwarf_count`` on 64-bit Linux again and fixed scanning script +- ``army_controller``: added new vector from 0.44.11 +- ``belief_system``: new type, few fields identified +- ``mental_picture``: new type, some fields identified +- ``mission_report``: + - new type (renamed, was ``mission`` before) + - identified some fields +- ``mission``: new type (used in ``viewscreen_civlistst``) +- ``spoils_report``: new type, most fields identified +- ``viewscreen_civlistst``: + - split ``unk_20`` into 3 pointers + - identified new pages + - identified new messenger-related fields +- ``viewscreen_image_creatorst``: + - fixed layout + - identified many fields +- ``viewscreen_reportlistst``: added new mission and spoils report-related fields (fixed layout) +- ``world.languages``: identified (minimal information; whole languages stored elsewhere) +- ``world.status``: + - ``mission_reports``: renamed, was ``missions`` + - ``spoils_reports``: identified +- ``world.unk_131ec0``, ``world.unk_131ef0``: researched layout +- ``world.worldgen_status``: identified many fields +- ``world``: ``belief_systems``: identified + + +DFHack 0.44.12-alpha1 +===================== + +Fixes +----- +- macOS: fixed ``renderer`` vtable address on x64 (fixes `rendermax`) +- `stonesense`: fixed ``PLANT:DESERT_LIME:LEAF`` typo + +API +--- +- Added C++-style linked list interface for DF linked lists + +Structures +---------- +- Dropped 0.44.11 support +- ``ui.squads``: Added fields new in 0.44.12 + + +DFHack 0.44.11-beta2.1 +====================== + +Internals +--------- +- `stonesense`: fixed build + + +DFHack 0.44.11-beta2 +==================== + +Fixes +----- +- Windows: Fixed console failing to initialize +- `command-prompt`: added support for commands that require a specific screen to be visible, e.g. `spotclean` +- `gui/workflow`: fixed advanced constraint menu for crafts + +API +--- +- Added ``Screen::Hide`` to temporarily hide screens, like `command-prompt` + + +DFHack 0.44.11-beta1 +==================== + +Fixes +----- +- Fixed displayed names (from ``Units::getVisibleName``) for units with identities +- Fixed potential memory leak in ``Screen::show()`` +- `fix/dead-units`: fixed script trying to use missing isDiplomat function + +Misc Improvements +----------------- +- Console: + - added support for multibyte characters on Linux/macOS + - made the console exit properly when an interactive command is active (`liquids`, `mode`, `tiletypes`) +- Linux: added automatic support for GCC sanitizers in ``dfhack`` script +- Made the ``DFHACK_PORT`` environment variable take priority over ``remote-server.json`` +- `dfhack-run`: added support for port specified in ``remote-server.json``, to match DFHack's behavior +- `digfort`: added better map bounds checking +- `remove-stress`: + - added support for ``-all`` as an alternative to the existing ``all`` argument for consistency + - sped up significantly + - improved output/error messages + - now removes tantrums, depression, and obliviousness +- `ruby`: sped up handling of onupdate events + +API +--- +- Exposed ``Screen::zoom()`` to C++ (was Lua-only) +- New functions: ``Units::isDiplomat(unit)`` + +Internals +--------- +- jsoncpp: updated to version 1.8.4 and switched to using a git submodule + +Lua +--- +- Added ``printall_recurse`` to print tables and DF references recursively. It can be also used with ``^`` from the `lua` interpreter. +- ``gui.widgets``: ``List:setChoices`` clones ``choices`` for internal table changes + +Structures +---------- +- ``history_event_entity_expels_hfst``: added (new in 0.44.11) +- ``history_event_site_surrenderedst``: added (new in 0.44.11) +- ``history_event_type``: added ``SITE_SURRENDERED``, ``ENTITY_EXPELS_HF`` (new in 0.44.11) +- ``syndrome``: identified a few fields +- ``viewscreen_civlistst``: fixed layout and identified many fields + + +DFHack 0.44.11-alpha1 +===================== + +Structures +---------- +- Added support for automatically sizing arrays indexed with an enum +- Dropped 0.44.10 support +- Removed stale generated CSV files and DT layouts from pre-0.43.05 +- ``announcement_type``: new in 0.44.11: ``NEW_HOLDING``, ``NEW_MARKET_LINK`` +- ``breath_attack_type``: added ``OTHER`` +- ``historical_figure_info.relationships.list``: added ``unk_3a``-``unk_3c`` fields at end +- ``interface_key``: added bindings new in 0.44.11 +- ``occupation_type``: new in 0.44.11: ``MESSENGER`` +- ``profession``: new in 0.44.11: ``MESSENGER`` +- ``ui_sidebar_menus``: + - ``unit.in_squad``: renamed to ``unit.squad_list_opened``, fixed location + - ``unit``: added ``expel_error`` and other unknown fields new in 0.44.11 + - ``hospital``: added, new in 0.44.11 + - ``num_speech_tokens``, ``unk_17d8``: moved out of ``command_line`` to fix layout on x64 +- ``viewscreen_civlistst``: added a few new fields (incomplete) +- ``viewscreen_locationsst``: identified ``edit_input`` + + +DFHack 0.44.10-r2 +================= + +New Plugins +----------- +- `cxxrandom`: exposes some features of the C++11 random number library to Lua + +New Scripts +----------- +- `add-recipe`: adds unknown crafting recipes to the player's civ +- `gui/stamper`: allows manipulation of designations by transforms such as translations, reflections, rotations, and inversion + +Fixes +----- +- Fixed many tools incorrectly using the ``dead`` unit flag (they should generally check ``flags2.killed`` instead) +- Fixed many tools passing incorrect arguments to printf-style functions, including a few possible crashes (`changelayer`, `follow`, `forceequip`, `generated-creature-renamer`) +- Fixed several bugs in Lua scripts found by static analysis (df-luacheck) +- Fixed ``-g`` flag (GDB) in Linux ``dfhack`` script (particularly on x64) +- `autochop`, `autodump`, `autogems`, `automelt`, `autotrade`, `buildingplan`, `dwarfmonitor`, `fix-unit-occupancy`, `fortplan`, `stockflow`: fix issues with periodic tasks not working for some time after save/load cycles +- `autogems`: + - stop running repeatedly when paused + - fixed crash when furnaces are linked to same stockpiles as jeweler's workshops +- `autogems`, `fix-unit-occupancy`: stopped running when a fort isn't loaded (e.g. while embarking) +- `autounsuspend`: now skips planned buildings +- `ban-cooking`: fixed errors introduced by kitchen structure changes in 0.44.10-r1 +- `buildingplan`, `fortplan`: stopped running before a world has fully loaded +- `deramp`: fixed deramp to find designations that already have jobs posted +- `dig`: fixed "Inappropriate dig square" announcements if digging job has been posted +- `fixnaked`: fixed errors due to emotion changes in 0.44 +- `remove-stress`: fixed an error when running on soul-less units (e.g. with ``-all``) +- `revflood`: stopped revealing tiles adjacent to tiles above open space inappropriately +- `stockpiles`: ``loadstock`` now sets usable and unusable weapon and armor settings +- `stocks`: stopped listing carried items under stockpiles where they were picked up from + +Misc Improvements +----------------- +- Added script name to messages produced by ``qerror()`` in Lua scripts +- Fixed an issue in around 30 scripts that could prevent edits to the files (adding valid arguments) from taking effect +- Linux: Added several new options to ``dfhack`` script: ``--remotegdb``, ``--gdbserver``, ``--strace`` +- `bodyswap`: improved error handling +- `buildingplan`: added max quality setting +- `caravan`: documented (new in 0.44.10-alpha1) +- `deathcause`: added "slaughtered" to descriptions +- `embark-assistant`: + - changed region interaction matching to search for evil rain, syndrome rain, and reanimation rather than interaction presence (misleadingly called evil weather), reanimation, and thralling + - gave syndrome rain and reanimation wider ranges of criterion values +- `fix/dead-units`: added a delay of around 1 month before removing units +- `fix/retrieve-units`: now re-adds units to active list to counteract `fix/dead-units` +- `modtools/create-unit`: + - added quantity argument + - now selects a caste at random if none is specified +- `mousequery`: + - migrated several features from TWBT's fork + - added ability to drag with left/right buttons + - added depth display for TWBT (when multilevel is enabled) + - made shift+click jump to lower levels visible with TWBT +- `title-version`: added version to options screen too +- ``item-descriptions``: fixed several grammatical errors + +API +--- +- New functions (also exposed to Lua): + - ``Units::isKilled()`` + - ``Units::isActive()`` + - ``Units::isGhost()`` +- Removed Vermin module (unused and obsolete) + +Internals +--------- +- Added build option to generate symbols for large generated files containing df-structures metadata +- Added fallback for YouCompleteMe database lookup failures (e.g. for newly-created files) +- Improved efficiency and error handling in ``stl_vsprintf`` and related functions +- jsoncpp: fixed constructor with ``long`` on Linux + +Lua +--- +- Added ``profiler`` module to measure lua performance +- Enabled shift+cursor movement in WorkshopOverlay-derived screens + +Structures +---------- +- ``incident_sub6_performance``: identified some fields +- ``item_body_component``: fixed location of ``corpse_flags`` +- ``job_handler``: fixed static array layout +- ``job_type``: added ``is_designation`` attribute +- ``unit_flags1``: renamed ``dead`` to ``inactive`` to better reflect its use +- ``unit_personality``: fixed location of ``current_focus`` and ``undistracted_focus`` +- ``unit_thought_type``: added ``SawDeadBody`` (new in 0.44.10) + + +DFHack 0.44.10-r1 +================= + +New Scripts +----------- +- `bodyswap`: shifts player control over to another unit in adventure mode + +New Tweaks +---------- +- `tweak` kitchen-prefs-all: adds an option to toggle cook/brew for all visible items in kitchen preferences +- `tweak` stone-status-all: adds an option to toggle the economic status of all stones + +Fixes +----- +- Lua: registered ``dfhack.constructions.designateRemove()`` correctly +- `prospector`: fixed crash due to invalid vein materials +- `tweak` max-wheelbarrow: fixed conflict with building renaming +- `view-item-info`: stopped appending extra newlines permanently to descriptions + +Misc Improvements +----------------- +- Added logo to documentation +- Documented several missing ``dfhack.gui`` Lua functions +- `adv-rumors`: bound to Ctrl-A +- `command-prompt`: added support for ``Gui::getSelectedPlant()`` +- `gui/advfort`: bound to Ctrl-T +- `gui/room-list`: added support for ``Gui::getSelectedBuilding()`` +- `gui/unit-info-viewer`: bound to Alt-I +- `modtools/create-unit`: made functions available to other scripts +- `search-plugin`: + - added support for stone restrictions screen (under ``z``: Status) + - added support for kitchen preferences (also under ``z``) + +API +--- +- New functions (all available to Lua as well): + - ``Buildings::getRoomDescription()`` + - ``Items::checkMandates()`` + - ``Items::canTrade()`` + - ``Items::canTradeWithContents()`` + - ``Items::isRouteVehicle()`` + - ``Items::isSquadEquipment()`` + - ``Kitchen::addExclusion()`` + - ``Kitchen::findExclusion()`` + - ``Kitchen::removeExclusion()`` +- syndrome-util: added ``eraseSyndromeData()`` + +Internals +--------- +- Fixed compiler warnings on all supported build configurations +- Windows build scripts now work with non-C system drives + +Structures +---------- +- ``dfhack_room_quality_level``: new enum +- ``glowing_barrier``: identified ``triggered``, added comments +- ``item_flags2``: renamed ``has_written_content`` to ``unk_book`` +- ``kitchen_exc_type``: new enum (for ``ui.kitchen``) +- ``mandate.mode``: now an enum +- ``unit_personality.emotions.flags.memory``: identified +- ``viewscreen_kitchenprefst.forbidden``, ``possible``: now a bitfield, ``kitchen_pref_flag`` +- ``world_data.feature_map``: added extensive documentation (in XML) + + +DFHack 0.44.10-beta1 +==================== + +New Scripts +----------- +- `devel/find-primitive`: finds a primitive variable in memory + +Fixes +----- +- Units::getAnyUnit(): fixed a couple problematic conditions and potential segfaults if global addresses are missing +- `autodump`, `automelt`, `autotrade`, `stocks`, `stockpiles`: fixed conflict with building renaming +- `exterminate`: fixed documentation of ``this`` option +- `full-heal`: + - units no longer have a tendency to melt after being healed + - healed units are no longer treated as patients by hospital staff + - healed units no longer attempt to clean themselves unsuccessfully + - wounded fliers now regain the ability to fly upon being healing + - now heals suffocation, numbness, infection, spilled guts and gelding +- `modtools/create-unit`: + - creatures of the appropriate age are now spawned as babies or children where applicable + - fix: civ_id is now properly assigned to historical_figure, resolving several hostility issues (spawned pets are no longer attacked by fortress military!) + - fix: unnamed creatures are no longer spawned with a string of numbers as a first name +- `stockpiles`: stopped sidebar option from overlapping with `autodump` +- `tweak` block-labors: fixed two causes of crashes related in the v-p-l menu + +Misc Improvements +----------------- +- `blueprint`: added a basic Lua API +- `devel/export-dt-ini`: added tool offsets for DT 40 +- `devel/save-version`: added current DF version to output +- `install-info`: added information on tweaks + +Internals +--------- +- Added function names to DFHack's NullPointer and InvalidArgument exceptions +- Added ``Gui::inRenameBuilding()`` +- Linux: required plugins to have symbols resolved at link time, for consistency with other platforms + + +DFHack 0.44.10-alpha1 +===================== + +New Scripts +----------- +- `caravan`: adjusts properties of caravans +- `gui/autogems`: a configuration UI for the `autogems` plugin + +Fixes +----- +- Fixed uninitialized pointer being returned from ``Gui::getAnyUnit()`` in rare cases +- `autohauler`, `autolabor`, `labormanager`: fixed fencepost error and potential crash +- `dwarfvet`: fixed infinite loop if an animal is not accepted at a hospital +- `liquids`: fixed "range" command to default to 1 for dimensions consistently +- `search-plugin`: fixed 4/6 keys in unit screen search +- `view-item-info`: fixed an error with some armor + +Misc Improvements +----------------- +- `autogems`: can now blacklist arbitrary gem types (see `gui/autogems`) +- `exterminate`: added more words for current unit, removed warning +- `fpause`: now pauses worldgen as well + +Internals +--------- +- Added some build scripts for Sublime Text +- Changed submodule URLs to relative URLs so that they can be cloned consistently over different protocols (e.g. SSH) + + +DFHack 0.44.09-r1 +================= + +Fixes +----- +- `modtools/item-trigger`: fixed token format in help text + +Misc Improvements +----------------- +- Reorganized changelogs and improved changelog editing process +- `modtools/item-trigger`: added support for multiple type/material/contaminant conditions + +Internals +--------- +- OS X: Can now build with GCC 7 (or older) + +Structures +---------- +- ``army``: added vector new in 0.44.07 +- ``building_type``: added human-readable ``name`` attribute +- ``furnace_type``: added human-readable ``name`` attribute +- ``renderer``: fixed vtable addresses on 64-bit OS X +- ``site_reputation_report``: named ``reports`` vector +- ``workshop_type``: added human-readable ``name`` attribute + + +DFHack 0.44.09-alpha1 +===================== + +Fixes +----- +- `digtype`: stopped designating non-vein tiles (open space, trees, etc.) +- `labormanager`: fixed crash due to dig jobs targeting some unrevealed map blocks + + +DFHack 0.44.08-alpha1 +===================== + +Fixes +----- +- `fix/dead-units`: fixed a bug that could remove some arriving (not dead) units + + +DFHack 0.44.07-beta1 +==================== + +Misc Improvements +----------------- +- `modtools/item-trigger`: added the ability to specify inventory mode(s) to trigger on + +Structures +---------- +- Added symbols for Toady's `0.44.07 Linux test build `_ to fix :bug:`10615` +- ``world_site``: fixed alignment + + +DFHack 0.44.07-alpha1 +===================== + +Fixes +----- +- Fixed some CMake warnings (CMP0022) +- Support for building on Ubuntu 18.04 +- `embark-assistant`: fixed detection of reanimating biomes + +Misc Improvements +----------------- +- `embark-assistant`: + - Added search for adamantine + - Now supports saving/loading profiles +- `fillneeds`: added ``-all`` option to apply to all units +- `remotefortressreader`: added flows, instruments, tool names, campfires, ocean waves, spiderwebs + +Structures +---------- +- Several new names in instrument raw structures +- ``identity``: identified ``profession``, ``civ`` +- ``manager_order_template``: fixed last field type +- ``viewscreen_createquotast``: fixed layout +- ``world.language``: moved ``colors``, ``shapes``, ``patterns`` to ``world.descriptors`` +- ``world.reactions``, ``world.reaction_categories``: moved to new compound, ``world.reactions``. Requires renaming: + - ``world.reactions`` to ``world.reactions.reactions`` + - ``world.reaction_categories`` to ``world.reactions.reaction_categories`` + + +DFHack 0.44.05-r2 +================= + +New Plugins +----------- +- `embark-assistant`: adds more information and features to embark screen + +New Scripts +----------- +- `adv-fix-sleepers`: fixes units in adventure mode who refuse to wake up (:bug:`6798`) +- `hermit`: blocks caravans, migrants, diplomats (for hermit challenge) + +New Features +------------ +- With ``PRINT_MODE:TEXT``, setting the ``DFHACK_HEADLESS`` environment variable will hide DF's display and allow the console to be used normally. (Note that this is intended for testing and is not very useful for actual gameplay.) + +Fixes +----- +- `devel/export-dt-ini`: fix language_name offsets for DT 39.2+ +- `devel/inject-raws`: fixed gloves and shoes (old typo causing errors) +- `remotefortressreader`: fixed an issue with not all engravings being included +- `view-item-info`: fixed an error with some shields + +Misc Improvements +----------------- +- `adv-rumors`: added more keywords, including names +- `autochop`: can now exclude trees that produce fruit, food, or cookable items +- `remotefortressreader`: added plant type support + + +DFHack 0.44.05-r1 +================= + +New Scripts +----------- +- `break-dance`: Breaks up a stuck dance activity +- `fillneeds`: Use with a unit selected to make them focused and unstressed +- `firestarter`: Lights things on fire: items, locations, entire inventories even! +- `flashstep`: Teleports adventurer to cursor +- `ghostly`: Turns an adventurer into a ghost or back +- `questport`: Sends your adventurer to the location of your quest log cursor +- `view-unit-reports`: opens the reports screen with combat reports for the selected unit + +Fixes +----- +- `devel/inject-raws`: now recognizes spaces in reaction names +- `dig`: added support for designation priorities - fixes issues with designations from ``digv`` and related commands having extremely high priority +- `dwarfmonitor`: + - fixed display of creatures and poetic/music/dance forms on ``prefs`` screen + - added "view unit" option + - now exposes the selected unit to other tools +- `names`: fixed many errors +- `quicksave`: fixed an issue where the "Saving..." indicator often wouldn't appear + +Misc Improvements +----------------- +- `binpatch`: now reports errors for empty patch files +- `force`: now provides useful help +- `full-heal`: + - can now select corpses to resurrect + - now resets body part temperatures upon resurrection to prevent creatures from freezing/melting again + - now resets units' vanish countdown to reverse effects of `exterminate` +- `gui/gm-unit`: + - added a profession editor + - misc. layout improvements +- `launch`: can now ride creatures +- `names`: can now edit names of units +- `remotefortressreader`: + - support for moving adventurers + - support for vehicles, gem shapes, item volume, art images, item improvements + +Removed +------- +- `tweak`: ``kitchen-keys``: :bug:`614` fixed in DF 0.44.04 + +Internals +--------- +- ``Gui::getAnyUnit()`` supports many more screens/menus + +Structures +---------- +- New globals: ``soul_next_id`` + + +DFHack 0.44.05-alpha1 +===================== + +Misc Improvements +----------------- +- `gui/liquids`: added more keybindings: 0-7 to change liquid level, P/B to cycle backwards + +Structures +---------- +- ``incident``: re-aligned again to match disassembly + + +DFHack 0.44.04-alpha1 +===================== + +Fixes +----- +- `devel/inject-raws`: now recognizes spaces in reaction names +- `exportlegends`: fixed an error that could occur when exporting empty lists + +Structures +---------- +- ``artifact_record``: fixed layout (changed in 0.44.04) +- ``incident``: fixed layout (changed in 0.44.01) - note that many fields have moved + + +DFHack 0.44.03-beta1 +==================== + +Fixes +----- +- `autolabor`, `autohauler`, `labormanager`: added support for "put item on display" jobs and building/destroying display furniture +- `gui/gm-editor`: fixed an error when editing primitives in Lua tables + +Misc Improvements +----------------- +- `devel/dump-offsets`: now ignores ``index`` globals +- `gui/pathable`: added tile types to sidebar +- `modtools/skill-change`: + - now updates skill levels appropriately + - only prints output if ``-loud`` is passed + +Structures +---------- +- Added ``job_type.PutItemOnDisplay`` +- Added ``twbt_render_map`` code offset on x64 +- Fixed an issue preventing ``enabler`` from being allocated by DFHack +- Found ``renderer`` vtable on osx64 +- New globals: + - ``version`` + - ``min_load_version`` + - ``movie_version`` + - ``basic_seed`` + - ``title`` + - ``title_spaced`` + - ``ui_building_resize_radius`` +- ``adventure_movement_optionst``, ``adventure_movement_hold_tilest``, ``adventure_movement_climbst``: named coordinate fields +- ``mission``: added type +- ``unit``: added 3 new vmethods: ``getCreatureTile``, ``getCorpseTile``, ``getGlowTile`` +- ``viewscreen_assign_display_itemst``: fixed layout on x64 and identified many fields +- ``viewscreen_reportlistst``: fixed layout, added ``mission_id`` vector +- ``world.status``: named ``missions`` vector + + +DFHack 0.44.03-alpha1 +===================== + +Lua +--- +- Improved ``json`` I/O error messages +- Stopped a crash when trying to create instances of classes whose vtable addresses are not available + + +DFHack 0.44.02-beta1 +==================== + +New Scripts +----------- +- `devel/check-other-ids`: Checks the validity of "other" vectors in the ``world`` global +- `gui/cp437-table`: An in-game CP437 table + +Fixes +----- +- Fixed issues with the console output color affecting the prompt on Windows +- `createitem`: stopped items from teleporting away in some forts +- `gui/gm-unit`: can now edit mining skill +- `gui/quickcmd`: stopped error from adding too many commands +- `modtools/create-unit`: fixed error when domesticating units + +Misc Improvements +----------------- +- The console now provides suggestions for built-in commands +- `devel/export-dt-ini`: avoid hardcoding flags +- `exportlegends`: + - reordered some tags to match DF's order + - added progress indicators for exporting long lists +- `gui/gm-editor`: added enum names to enum edit dialogs +- `gui/gm-unit`: made skill search case-insensitive +- `gui/rename`: added "clear" and "special characters" options +- `remotefortressreader`: + - includes item stack sizes + - some performance improvements + +Removed +------- +- `warn-stuck-trees`: :bug:`9252` fixed in DF 0.44.01 + +Lua +--- +- Exposed ``get_vector()`` (from C++) for all types that support ``find()``, e.g. ``df.unit.get_vector() == df.global.world.units.all`` + +Structures +---------- +- Added ``buildings_other_id.DISPLAY_CASE`` +- Fixed ``unit`` alignment +- Fixed ``viewscreen_titlest.start_savegames`` alignment +- Identified ``historical_entity.unknown1b.deities`` (deity IDs) +- Located ``start_dwarf_count`` offset for all builds except 64-bit Linux; `startdwarf` should work now + + +DFHack 0.44.02-alpha1 +===================== + +New Scripts +----------- +- `devel/dump-offsets`: prints an XML version of the global table included in in DF + +Fixes +----- +- Fixed a crash that could occur if a symbol table in symbols.xml had no content + +Lua +--- +- Added a new ``dfhack.console`` API +- API can now wrap functions with 12 or 13 parameters + +Structures +---------- +- The former ``announcements`` global is now a field in ``d_init`` +- The ``ui_menu_width`` global is now a 2-byte array; the second item is the former ``ui_area_map_width`` global, which is now removed +- ``world`` fields formerly beginning with ``job_`` are now fields of ``world.jobs``, e.g. ``world.job_list`` is now ``world.jobs.list`` + + +DFHack 0.43.05-r3 +================= + +Internals +--------- +- Fixed an uncommon crash that could occur when printing text to the console +- Added lots of previously-missing DF classes +- More names for fields: https://github.com/DFHack/df-structures/compare/0.43.05-r2...0.43.05 + +Fixes +----- +- Linux: fixed argument to ``setarch`` in the ``dfhack`` launcher script +- Ruby: fixed an error that occurred when the DF path contained an apostrophe +- `diggingInvaders` now compiles again and is included +- `labormanager`: + + - stopped waiting for on-duty military dwarves with minor injuries to obtain care + - stopped waiting for meetings when participant(s) are dead + - fixed a crash for dwarves with no cultural identity + +- `luasocket`: fixed ``receive()`` with a byte count +- `orders`: fixed an error when importing orders with material categories +- `siren`: fixed an error +- `stockpiles`: fixed serialization of barrel and bin counts +- `view-item-info`: fixed a ``CHEESE_MAT``-related error + +Misc Improvements +----------------- +- `devel/export-dt-ini`: added more offsets for new DT versions +- `digfort`: added support for changing z-levels +- `exportlegends`: suppressed ABSTRACT_BUILDING warning +- `gui/dfstatus`: excluded logs in constructions +- `labormanager`: + + - stopped assigning woodcutting jobs to elves + - "recover wounded" jobs now weighted based on altruism + +- `remotefortressreader`: added support for buildings, grass, riders, and + hair/beard styles + + +DFHack 0.43.05-r2 +================= + +Internals +--------- +- Rebuilding DFHack can be faster if nothing Git-related has changed +- Plugins can now hook Screen::readTile() +- Improved Lua compatibility with plugins that hook into GUI functions (like TWBT) +- Expanded focus strings for jobmanagement and workquota_condition viewscreens +- ``Gui::getAnyUnit()``: added support for viewscreen_unitst, + viewscreen_textviewerst, viewscreen_layer_unit_relationshipst +- Fixed (limited) keybinding support in PRINT_MODE:TEXT on macOS +- Added a new standardized ``Gui::refreshSidebar()`` function to fix behavior of + some plugins on the lowest z-level +- New ``Buildings`` module functions: ``markedForRemoval()``, ``getCageOccupants()`` +- Limited recursive command invocations to 20 to prevent crashes +- Added an ``onLoad.init-example`` file + +Lua +--- +- Improved C++ exception handling for some native functions that aren't direct + wrappers around C++ functions (in this case, error messages could be nil and + cause the Lua interpreter to quit) +- Added support for a ``key_pen`` option in Label widgets +- Fixed ``to_first`` argument to ``dfhack.screen.dismiss()`` +- Added optional ``map`` parameters to some screen functions +- Exposed some more functions to Lua: + + - ``dfhack.gui.refreshSidebar()`` + - ``dfhack.gui.getAnyUnit()`` + - ``dfhack.gui.getAnyBuilding()`` + - ``dfhack.gui.getAnyItem()`` + - ``dfhack.gui.getAnyPlant()`` + - ``dfhack.gui.getDepthAt()`` + - ``dfhack.units.getUnitsInBox()`` + - ``dfhack.units.isVisible()`` + - ``dfhack.maps.isTileVisible()`` + - ``dfhack.buildings.markedForRemoval()`` + - ``dfhack.buildings.getCageOccupants()`` + - ``dfhack.internal.md5()`` + - ``dfhack.internal.md5File()`` + - ``dfhack.internal.threadid()`` + +- New function: ``widgets.Pages:getSelectedPage()`` +- Added a ``key`` option to EditField and FilteredList widgets +- Fixed an issue preventing ``repeatUtil.cancel()`` from working when called + from the callback + +Ruby +---- +- Fixed a crash when creating new instances of DF virtual classes (e.g. fixes a + `lever` crash) +- Ruby scripts can now be loaded from any script paths specified (from script- + paths.txt or registered through the Lua API) +- ``unit_find()`` now uses ``Gui::getSelectedUnit()`` and works in more places + (e.g. `exterminate` now works from more screens, like `command-prompt`) + +New Internal Commands +--------------------- +- `alias`: allows configuring aliases for other commands + +New Plugins +----------- +- `orders`: Manipulate manager orders +- `pathable`: Back-end for `gui/pathable` + +New Scripts +----------- +- `clear-smoke`: Removes all smoke from the map +- `empty-bin`: Empty a bin onto the floor +- `fix/retrieve-units`: Spawns stuck invaders/guests +- `fix/stuck-merchants`: Dismisses stuck merchants that haven't entered the map yet +- `gui/pathable`: View whether tiles on the map can be pathed to +- `gui/teleport`: A front-end for the `teleport` script +- `warn-stuck-trees`: Detects citizens stuck in trees + +New Tweaks +---------- +- `tweak` burrow-name-cancel: Implements the "back" option when renaming a + burrow, which currently does nothing (:bug:`1518`) +- `tweak` cage-butcher: Adds an option to butcher units when viewing cages with "q" + +Fixes +----- +- Enforced use of ``stdout.log`` and ``stderr.log`` (instead of their ``.txt`` + counterparts) on Windows +- Fixed ``getItemBaseValue()`` for cheese, sheets and instruments +- Fixed alignment in: + + - ``viewscreen_choose_start_sitest`` + - ``viewscreen_export_graphical_mapst`` + - ``viewscreen_setupadventurest`` + - ``viewscreen_setupdwarfgamest`` + +- `adv-max-skills`: fixed error due to viewscreen changes +- `autolabor`: fixed a crash when assigning haulers while traders are active +- `buildingplan`: fixed an issue that prevented certain numbers from being used + in building names +- `confirm`: + + - dialogs are now closed permanently when disabled from the settings UI + - fixed an issue that could have prevented closing dialogs opened by pressing "s" + +- `embark-tools`: stopped the sand indicator from overlapping dialogs +- `exportlegends`: fixed some crashes and site map issues +- `devel/find-offsets`: fixed ``current_weather`` scan +- `gui/extended-status`: fixed an error when no beds are available +- `gui/family-affairs`: fixed issues with assigning lovers +- `gui/gm-editor`: + + - made keybinding display order consistent + - stopped keys from performing actions in help screen + +- `gui/manager-quantity`: + + - now allows orders with a limit of 0 + - fixed screen detection + +- `gui/mechanisms`, `gui/room-list`: fixed an issue when recentering the map when exiting +- `lever`: prevented pulling non-lever buildings, which can cause crashes +- `markdown`: fixed file encoding +- `modtools/create-unit`: + + - fixed when popup announcements are present + - added checks to ensure that the current game mode is restored + +- `resume`: stopped drawing on the map border +- `show-unit-syndromes`: fixed an error when handling some syndromes +- `strangemood`: fixed some issues with material searches +- `view-item-info`: fixed a color-related error for some materials + +Misc Improvements +----------------- +- Docs: prevented automatic hyphenation in some browsers, which was producing + excessive hyphenation sometimes +- `command-prompt`: invoking ``command-prompt`` a second time now hides the prompt +- `gui/extended-status`: added an option to assign/replace the manager +- `gui/load-screen`: + + - adjusted dialog width for long folder names + - added modification times and DF versions to dialog + +- `gui/mechanisms`, `gui/room-list`, `gui/siege-engine`: add and list "exit to map" options +- `lever`: added support for pulling levers at high priority +- `markdown`: now recognizes ``-n`` in addition to ``/n`` +- `remotefortressreader`: more data exported, used by Armok Vision v0.17.0 +- `resume`, `siege-engine`: improved compatibility with GUI-hooking plugins (like TWBT) +- `sc-script`: improved help text +- `teleport`: can now be used as a module +- `tweak` embark-profile-name: now enabled in ``dfhack.init-example`` +- `tweak` hotkey-clear: fixed display on larger screens + + +DFHack 0.43.05-r1 +================= + +Internals +--------- +- 64-bit support on all platforms +- Several structure fixes to match 64-bit DF's memory layout +- Added ``DFHack::Job::removeJob()`` function +- New module: ``Designations`` - handles designation creation (currently for plants only) +- Added ``Gui::getSelectedPlant()`` +- Added ``Units::getMainSocialActivity()``, ``Units::getMainSocialEvent()`` +- Visual Studio 2015 now required to build on Windows instead of 2010 +- GCC 4.8 or newer required to build on Linux and OS X (and now supported on OS X) +- Updated TinyXML from 2.5.3 to 2.6.2 +- Added the ability to download files manually before building + +Lua +--- +- Lua has been updated to 5.3 - see https://www.lua.org/manual/5.3/readme.html for details + + - Floats are no longer implicitly converted to integers in DFHack API calls + +- ``df.new()`` supports more types: ``char``, ``intptr_t``, ``uintptr_t``, ``long``, ``unsigned long`` +- String representations of vectors and a few other containers now include their lengths +- Added a ``tile-material`` module +- Added a ``Painter:key_string()`` method +- Made ``dfhack.gui.revealInDwarfmodeMap()`` available + +Ruby +---- +- Added support for loading ruby 2.x libraries + +New Plugins +----------- +- `dwarfvet` enables animal caretaking +- `generated-creature-renamer`: Renames generated creature IDs for use with graphics packs +- `labormanager` (formerly autolabor2): a more advanced alternative to `autolabor` +- `misery`: re-added and updated for the 0.4x series +- `title-folder`: shows DF folder name in window title bar when enabled + +New Scripts +----------- +- `adv-rumors`: improves the "Bring up specific incident or rumor" menu in adventure mode +- `fix/tile-occupancy`: Clears bad occupancy flags on the selected tile. +- `install-info`: Logs basic troubleshooting information about the current DFHack installation +- `load-save`: loads a save non-interactively +- `modtools/change-build-menu`: Edit the build mode sidebar menus +- `modtools/if-entity`: Run a command if the current entity matches a given ID +- `season-palette`: Swap color palettes with the changes of the seasons +- `unforbid`: Unforbids all items + +New Tweaks +---------- +- `tweak condition-material `: fixes a crash in the work order condition material list +- `tweak hotkey-clear `: adds an option to clear bindings from DF hotkeys + +Fixes +----- +- The DF path on OS X can now contain spaces and ``:`` characters +- Buildings::setOwner() changes now persist properly when saved +- ``ls`` now lists scripts in folders other than ``hack/scripts``, when applicable +- Fixed ``plug`` output alignment for plugins with long names +- `add-thought`: fixed support for emotion names +- `autochop`: + + - fixed several issues with job creation and removal + - stopped designating the center tile (unreachable) for large trees + - stopped options from moving when enabling and disabling burrows + - fixed display of unnamed burrows + +- `devel/find-offsets`: fixed a crash when vtables used by globals aren't available +- `getplants`: + + - fixed several issues with job creation and removal + - stopped designating the center tile (unreachable) for large trees + +- `gui/workflow`: added extra keybinding to work with `gui/extended-status` +- `manipulator`: + + - Fixed crash when selecting a profession from an empty list + - Custom professions are now sorted alphabetically more reliably + +- `modtools/create-item`: + + - made gloves usable by specifying handedness + - now creates pairs of boots and gloves + +- `modtools/create-unit`: + + - stopped permanently overwriting the creature creation menu in arena mode + - now uses non-English names + - added ``-setUnitToFort`` option to make a unit a civ/group member more easily + - fixed some issues where units would appear in unrevealed areas of the map + +- `modtools/item-trigger`: fixed errors with plant growths +- `remotefortressreader`: fixed a crash when serializing the local map +- `ruby`: fixed a crash when unloading the plugin on Windows +- `stonesense`: disabled overlay in STANDARD-based print modes to prevent crashes +- `title-version`: now hidden when loading an arena + +Misc Improvements +----------------- +- Documented all default keybindings (from :file:`dfhack.init-example`) in the + docs for the relevant commands; updates enforced by build system. +- `autounsuspend`: reduced update frequency to address potential performance issues +- `gui/extended-status`: added a feature to queue beds +- `lua` and `gui/gm-editor` now support the same aliases (``scr``, ``unit``, etc.) +- `manipulator`: added social activities to job column +- `remotefortressreader`: Added support for + + - world map snow coverage + - spatters + - wall info + - site towers, world buildings + - surface material + - building items + - DF version info + +- `title-version`: Added a prerelease indicator +- `workflow`: Re-added ``Alt-W`` keybindings + + +DFHack 0.43.05-beta2 +==================== + +Fixes +----- +- Fixed Buildings::updateBuildings(), along with building creation/deletion events +- Fixed ``plug`` output alignment for plugins with long names +- Fixed a crash that happened when a ``LUA_PATH`` environment variable was set +- `add-thought`: fixed number conversion +- `gui/workflow`: fixed range editing producing the wrong results for certain numbers +- `modtools/create-unit`: now uses non-English names +- `modtools/item-trigger`: fixed errors with plant growths +- `remotefortressreader`: fixed a crash when serializing the local map +- `stockflow`: fixed an issue with non-integer manager order limits +- `title-folder`: fixed compatibility issues with certain SDL libraries on macOS + +Structures +---------- +- Added some missing renderer VTable addresses on macOS +- ``entity.resources.organic``: identified ``parchment`` +- ``entity_sell_category``: added ``Parchment`` and ``CupsMugsGoblets`` +- ``ui_advmode_menu``: added ``Build`` +- ``ui_unit_view_mode``: added ``PrefOccupation`` +- ``unit_skill``: identified ``natural_skill_lvl`` (was ``unk_1c``) +- ``viewscreen_jobmanagementst``: identified ``max_workshops`` +- ``viewscreen_overallstatusst``: made ``visible_pages`` an enum +- ``viewscreen_pricest``: identified fields +- ``viewscreen_workquota_conditionst``: gave some fields ``unk`` names + +API Changes +----------- +- Allowed the Lua API to accept integer-like floats and strings when expecting an integer +- Lua: New ``Painter:key_string()`` method +- Lua: Added ``dfhack.getArchitecture()`` and ``dfhack.getArchitectureName()`` + +Additions/Removals: +------------------- +- Added `adv-rumors` script: improves the "Bring up specific incident or rumor" menu in adventure mode +- Added `install-info` script for basic troubleshooting +- Added `tweak condition-material `: fixes a crash in the work order condition material list +- Added `tweak hotkey-clear `: adds an option to clear bindings from DF hotkeys +- `autofarm`: reverted local biome detection (from 0.43.05-alpha3) + +Other Changes +------------- +- Added a DOWNLOAD_RUBY CMake option, to allow use of a system/external ruby library +- Added the ability to download files manually before building +- `gui/extended-status`: added a feature to queue beds +- `remotefortressreader`: added building items, DF version info +- `stonesense`: Added support for 64-bit macOS and Linux + +DFHack 0.43.05-beta1 +==================== + +Fixes +----- +- Fixed various crashes on 64-bit Windows related to DFHack screens, notably `manipulator` +- Fixed addresses of next_id globals on 64-bit Linux (fixes an `automaterial`/box-select crash) +- ``ls`` now lists scripts in folders other than ``hack/scripts``, when applicable +- `modtools/create-unit`: stopped permanently overwriting the creature creation + menu in arena mode +- `season-palette`: fixed an issue where only part of the screen was redrawn + after changing the color scheme +- `title-version`: now hidden when loading an arena + +Structures +---------- +- ``file_compressorst``: fixed field sizes on x64 +- ``historical_entity``: fixed alignment on x64 +- ``ui_sidebar_menus.command_line``: fixed field sizes on x64 +- ``viewscreen_choose_start_sitest``: added 3 missing fields, renamed ``in_embark_only_warning`` +- ``viewscreen_layer_arena_creaturest``: identified more fields +- ``world.math``: identified +- ``world.murky_pools``: identified + +Additions/Removals +------------------ +- `generated-creature-renamer`: Renames generated creature IDs for use with graphics packs + +Other Changes +------------- +- `title-version`: Added a prerelease indicator + +DFHack 0.43.05-alpha4 +===================== + +Fixes +----- +- Fixed an issue with uninitialized bitfields that was causing several issues + (disappearing buildings in `buildingplan`'s planning mode, strange behavior in + the extended `stocks` screen, and likely other problems). This issue was + introduced in 0.43.05-alpha3. +- `stockflow`: Fixed an "integer expected" error + +Structures +---------- +- Located several globals on 64-bit Linux: flows, timed_events, ui_advmode, + ui_building_assign_type, ui_building_assign_is_marked, + ui_building_assign_units, ui_building_assign_items, and ui_look_list. This + fixes `search-plugin`, `zone`, and `force`, among others. +- ``ui_sidebar_menus``: Fixed some x64 alignment issues + +Additions/Removals +------------------ +- Added `fix/tile-occupancy`: Clears bad occupancy flags on the selected tile. + Useful for fixing blocked tiles introduced by the above buildingplan issue. +- Added a Lua ``tile-material`` module + +Other Changes +------------- +- `labormanager`: Add support for shell crafts +- `manipulator`: Custom professions are now sorted alphabetically more reliably + +DFHack 0.43.05-alpha3 +===================== + +Fixes +----- +- `add-thought`: fixed support for emotion names +- `autofarm`: Made surface farms detect local biome +- `devel/export-dt-ini`: fixed squad_schedule_entry size +- `labormanager`: + + - Now accounts for unit attributes + - Made instrument-building jobs work (constructed instruments) + - Fixed deconstructing constructed instruments + - Fixed jobs in bowyer's shops + - Fixed trap component jobs + - Fixed multi-material construction jobs + - Fixed deconstruction of buildings containing items + - Fixed interference caused by "store item in vehicle" jobs + +- `manipulator`: Fixed crash when selecting a profession from an empty list +- `ruby`: + + - Fixed crash on Win64 due to truncated global addresses + - Fixed compilation on Win64 + - Use correct raw string length with encodings + +Structures +---------- +- Changed many ``comment`` XML attributes with version numbers to use new + ``since`` attribute instead +- ``activity_event_conflictst.sides``: named many fields +- ``building_def.build_key``: fixed size on 64-bit Linux and OS X +- ``historical_kills``: + + - ``unk_30`` -> ``killed_underground_region`` + - ``unk_40`` -> ``killed_region`` + +- ``historical_kills.killed_undead``: removed ``skeletal`` flag +- ``ui_advmode``: aligned enough so that it doesn't crash (64-bit OS X/Linux) +- ``ui_advmode.show_menu``: changed from bool to enum +- ``unit_personality.emotions.flags``: now a bitfield + +API Changes +----------- +- Added ``DFHack::Job::removeJob()`` function +- C++: Removed bitfield constructors that take an initial value. These kept + bitfields from being used in unions. Set ``bitfield.whole`` directly instead. +- Lua: ``bitfield.whole`` now returns an integer, not a decimal + +Additions/Removals +------------------ +- Removed source for treefarm plugin (wasn't built) +- Added `modtools/change-build-menu`: Edit the build mode sidebar menus +- Added `modtools/if-entity`: Run a command if the current entity matches a + given ID +- Added `season-palette`: Swap color palettes with the changes of the seasons + +Other changes +------------- +- Changed minimum GCC version to 4.8 on OS X and Linux (earlier versions + wouldn't have worked on Linux anyway) +- Updated TinyXML from 2.5.3 to 2.6.2 + +DFHack 0.43.03-r1 +================= + +Lua +--- +- Label widgets can now easily register handlers for mouse clicks + +New Features +------------ +- `add-thought`: allow syndrome name as ``-thought`` argument +- `gui/gm-editor` + + - Added ability to insert default types into containers. For primitive types leave the type entry empty, and for references use ``*``. + - Added ``shift-esc`` binding to fully exit from editor + - Added ``gui/gm-editor toggle`` command to toggle editor visibility (saving position) + +- `modtools/create-unit`: + + - Added an option to attach units to an existing wild animal population + - Added an option to attach units to a map feature + +Fixes +----- +- `autofarm`: Can now handle crops that grow for more than a season +- `combine-plants`: Fixed recursion into sub-containers +- `createitem`: Now moves multiple created items to cursor correctly +- `exportlegends`: Improved handling of unknown enum items (fixes many errors) +- `gui/create-item`: Fixed quality when creating multiple items +- `gui/mod-manager`: Fixed error when mods folder doesn't exist +- `modtools/item-trigger`: Fixed handling of items with subtypes +- `reveal`: ``revflood`` now handles constructed stairs with floors in generated fortresses +- `stockflow`: + + - Can order metal mechanisms + - Fixed material category of thread-spinning jobs + +Misc Improvements +----------------- +- The built-in ``ls`` command now wraps the descriptions of commands +- `catsplosion`: now a lua script instead of a plugin +- `fix/diplomats`: replaces ``fixdiplomats`` +- `fix/merchants`: replaces ``fixmerchants`` +- `prefchange`: added a ``help`` option +- `probe`: now displays raw tiletype names +- Unified script documentation and in-terminal help options + +Removed +------- +- `tweak` manager-quantity: no longer needed + +DFHack 0.42.06-r1 +================= + +Internals +--------- +- Commands to run on startup can be specified on the command line with ``+`` + + Example:: + + ./dfhack +devel/print-args example + "Dwarf Fortress.exe" +devel/print-args example + +- Prevented plugins with active viewscreens from being unloaded and causing a crash +- Additional script search paths can be specified in dfhack-config/script-paths.txt + +Lua +--- +- `building-hacks` now supports ``auto_gears`` flags. It automatically finds and animates gears in building definition +- Changed how `eventful` triggers reaction complete. Now it has ``onReactionComplete`` and ``onReactionCompleting``. Second one can be canceled + +New Plugins +----------- +- `autogems`: Creates a new Workshop Order setting, automatically cutting rough gems + +New Scripts +----------- +- `devel/save-version`: Displays DF version information about the current save +- `modtools/extra-gamelog`: replaces ``log-region``, ``soundsense-season``, and ``soundsense`` + +New Features +------------ +- `buildingplan`: Support for floodgates, grates, and bars +- `colonies`: new ``place`` subcommand and supports any vermin (default honey bees) +- `confirm`: Added a confirmation for retiring locations +- `exportlegends`: Exports more information (poetic/musical/dance forms, written/artifact content, landmasses, extra histfig information, and more) +- `search-plugin`: Support for new screens: + + - location occupation assignment + - civilization animal training knowledge + - animal trainer assignment + +- `tweak`: + + - ``tweak block-labors``: Prevents labors that can't be used from being toggled + - ``tweak hide-priority``: Adds an option to hide designation priority indicators + - ``tweak title-start-rename``: Adds a safe rename option to the title screen "Start Playing" menu + +- `zone`: + + - Added ``unassign`` subcommand + - Added ``only`` option to ``assign`` subcommand + +Fixes +----- +- Fixed a crash bug caused by the historical figures DFHack uses to store persistent data. +- More plugins should recognize non-dwarf citizens +- Fixed a possible crash from cloning jobs +- moveToBuilding() now sets flags for items that aren't a structural part of the building properly +- `autotrade`, `stocks`: Made trading work when multiple caravans are present but only some can trade +- `confirm` note-delete: No longer interferes with name entry +- `exportlegends`: Handles entities without specific races, and a few other fixes for things new to v0.42 +- `fastdwarf`: Fixed a bug involving teleporting mothers but not the babies they're holding. +- `gaydar`: Fixed text display on OS X/Linux and failure with soul-less creatures +- `manipulator`: + + - allowed editing of non-dwarf citizens + - stopped ghosts and visitors from being editable + - fixed applying last custom profession + +- `modtools/create-unit`: Stopped making units without civs historical figures +- `modtools/force`: + + - Removed siege option + - Prevented a crash resulting from a bad civilization option + +- `showmood`: Fixed name display on OS X/Linux +- `view-item-info`: Fixed density units + +Misc Improvements +----------------- +- `autochop`: Can now edit log minimum/maximum directly and remove limit entirely +- `autolabor`, `autohauler`, `manipulator`: Added support for new jobs/labors/skills +- `colonies`: now implemented by a script +- `createitem`: Can now create items anywhere without specifying a unit, as long as a unit exists on the map +- `devel/export-dt-ini`: Updated for 0.42.06 +- `devel/find-offsets`: Automated several more scans +- `gui/gm-editor`: Now supports finding some items with a numeric ID (with ``i``) +- `lua`: Now supports some built-in variables like `gui/gm-editor`, e.g. ``unit``, ``screen`` +- `remotefortressreader`: Can now trigger keyboard events +- `stockflow`: Now offers better control over individual craft jobs +- `weather`: now implemented by a script +- `zone`: colored output + +Removed +------- +- DFusion: legacy script system, obsolete or replaced by better alternatives + + +DFHack 0.40.24-r5 +================= + +New Features +------------ +- `confirm`: + + - Added a ``uniform-delete`` option for military uniform deletion + - Added a basic in-game configuration UI + +Fixes +----- +- Fixed a rare crash that could result from running `keybinding` in onLoadWorld.init +- Script help that doesn't start with a space is now recognized correctly +- `confirm`: Fixed issues with haul-delete, route-delete, and squad-disband confirmations intercepting keys too aggressively +- `emigration` should work now +- `fix-unit-occupancy`: Significantly optimized - up to 2,000 times faster in large fortresses +- `gui/create-item`: Allow exiting quantity prompt +- `gui/family-affairs`: Fixed an issue where lack of relationships wasn't recognized and other issues +- `modtools/create-unit`: Fixed a possible issue in reclaim fortress mode +- `search-plugin`: Fixed a crash on the military screen +- `tweak` max-wheelbarrow: Fixed a minor display issue with large numbers +- `workflow`: Fixed a crash related to job postings (and added a fix for existing, broken jobs) + +Misc Improvements +----------------- +- Unrecognized command feedback now includes more information about plugins +- `fix/dry-buckets`: replaces the ``drybuckets`` plugin +- `feature`: now implemented by a script + +DFHack 0.40.24-r4 +================= + +Internals +--------- +- A method for caching screen output is now available to Lua (and C++) +- Developer plugins can be ignored on startup by setting the ``DFHACK_NO_DEV_PLUGINS`` environment variable +- The console on Linux and OS X now recognizes keyboard input between prompts +- JSON libraries available (C++ and Lua) +- More DFHack build information used in plugin version checks and available to plugins and lua scripts +- Fixed a rare overflow issue that could cause crashes on Linux and OS X +- Stopped DF window from receiving input when unfocused on OS X +- Fixed issues with keybindings involving :kbd:`Ctrl`:kbd:`A` and :kbd:`Ctrl`:kbd:`Z`, + as well as :kbd:`Alt`:kbd:`E`/:kbd:`U`/:kbd:`N` on OS X +- Multiple contexts can now be specified when adding keybindings +- Keybindings can now use :kbd:`F10`-:kbd:`F12` and :kbd:`0`-:kbd:`9` +- Plugin system is no longer restricted to plugins that exist on startup +- :file:`dfhack.init` file locations significantly generalized + +Lua +--- +- Scripts can be enabled with the built-in `enable`/`disable ` commands +- A new function, ``reqscript()``, is available as a safer alternative to ``script_environment()`` +- Lua viewscreens can choose not to intercept the OPTIONS keybinding + +New internal commands +--------------------- +- `kill-lua`: Interrupt running Lua scripts +- `type`: Show where a command is implemented + +New plugins +----------- +- `confirm`: Adds confirmation dialogs for several potentially dangerous actions +- `fix-unit-occupancy`: Fixes issues with unit occupancy, such as faulty "unit blocking tile" messages (:bug:`3499`) +- `title-version` (formerly ``vshook``): Display DFHack version on title screen + +New scripts +----------- +- `armoks-blessing`: Adjust all attributes, personality, age and skills of all dwarves in play +- `brainwash`: brainwash a dwarf (modifying their personality) +- `burial`: sets all unowned coffins to allow burial ("-pets" to allow pets too) +- `deteriorateclothes`: make worn clothes on the ground wear far faster to boost FPS +- `deterioratecorpses`: make body parts wear away far faster to boost FPS +- `deterioratefood`: make food vanish after a few months if not used +- `elevate-mental`: elevate all the mental attributes of a unit +- `elevate-physical`: elevate all the physical attributes of a unit +- `emigration`: stressed dwarves may leave your fortress if they see a chance +- `fix-ster`: changes fertility/sterility of animals or dwarves +- `gui/family-affairs`: investigate and alter romantic relationships +- `make-legendary`: modify skill(s) of a single unit +- `modtools/create-unit`: create new units from nothing +- `modtools/equip-item`: a script to equip items on units +- `points`: set number of points available at embark screen +- `pref-adjust`: Adjust all preferences of all dwarves in play +- `rejuvenate`: make any "old" dwarf 20 years old +- `starvingdead`: make undead weaken after one month on the map, and crumble after six +- `view-item-info`: adds information and customisable descriptions to item viewscreens +- `warn-starving`: check for starving, thirsty, or very drowsy units and pause with warning if any are found + +New tweaks +---------- +- embark-profile-name: Allows the use of lowercase letters when saving embark profiles +- kitchen-keys: Fixes DF kitchen meal keybindings +- kitchen-prefs-color: Changes color of enabled items to green in kitchen preferences +- kitchen-prefs-empty: Fixes a layout issue with empty kitchen tabs + +Fixes +----- +- Plugins with vmethod hooks can now be reloaded on OS X +- Lua's ``os.system()`` now works on OS X +- Fixed default arguments in Lua gametype detection functions +- Circular lua dependencies (reqscript/script_environment) fixed +- Prevented crash in ``Items::createItem()`` +- `buildingplan`: Now supports hatch covers +- `gui/create-item`: fixed assigning quality to items, made :kbd:`Esc` work properly +- `gui/gm-editor`: handles lua tables properly +- `help`: now recognizes built-in commands, like ``help`` +- `manipulator`: fixed crash when selecting custom professions when none are found +- `remotefortressreader`: fixed crash when attempting to send map info when no map was loaded +- `search-plugin`: fixed crash in unit list after cancelling a job; fixed crash when disabling stockpile category after searching in a subcategory +- `stockpiles`: now checks/sanitizes filenames when saving +- `stocks`: fixed a crash when right-clicking +- `steam-engine`: fixed a crash on arena load; number keys (e.g. 2/8) take priority over cursor keys when applicable +- tweak fps-min fixed +- tweak farm-plot-select: Stopped controls from appearing when plots weren't fully built +- `workflow`: Fixed some issues with stuck jobs. Existing stuck jobs must be cancelled and re-added +- `zone`: Fixed a crash when using ``zone set`` (and a few other potential crashes) + +Misc Improvements +----------------- +- DFHack documentation: + + - massively reorganised, into files of more readable size + - added many missing entries + - indexes, internal links, offline search all documents + - includes documentation of linked projects (df-structures, third-party scripts) + - better HTML generation with Sphinx + - documentation for scripts now located in source files + +- `autolabor`: + + - Stopped modification of labors that shouldn't be modified for brokers/diplomats + - Prioritize skilled dwarves more efficiently + - Prevent dwarves from running away with tools from previous jobs + +- `automaterial`: Fixed several issues with constructions being allowed/disallowed incorrectly when using box-select +- `dwarfmonitor`: + + - widgets' positions, formats, etc. are now customizable + - weather display now separated from the date display + - New mouse cursor widget + +- `gui/dfstatus`: Can enable/disable individual categories and customize metal bar list +- `full-heal`: ``-r`` option removes corpses +- `gui/gm-editor` + + - Pointers can now be displaced + - Added some useful aliases: "item" for the selected item, "screen" for the current screen, etc. + - Now avoids errors with unrecognized types + +- `gui/hack-wish`: renamed to `gui/create-item` +- `keybinding list ` accepts a context +- `lever`: + + - Lists lever names + - ``lever pull`` can be used to pull the currently-selected lever + +- ``memview``: Fixed display issue +- `modtools/create-item`: arguments are named more clearly, and you can specify the creator to be the unit with id ``df.global.unit_next_id-1`` (useful in conjunction with `modtools/create-unit`) +- ``nyan``: Can now be stopped with dfhack-run +- `plug`: lists all plugins; shows state and number of commands in plugins +- `prospect`: works from within command-prompt +- `quicksave`: Restricted to fortress mode +- `remotefortressreader`: Exposes more information +- `search-plugin`: + + - Supports noble suggestion screen (e.g. suggesting a baron) + - Supports fortress mode loo[k] menu + - Recognizes ? and ; keys + +- `stocks`: can now match beginning and end of item names +- `teleport`: Fixed cursor recognition +- `tidlers`, `twaterlvl`: now implemented by scripts instead of a plugin +- `tweak`: + + - debug output now logged to stderr.log instead of console - makes DFHack start faster + - farm-plot-select: Fixed issues with selecting undiscovered crops + +- `workflow`: Improved handling of plant reactions + +Removed +------- +- `embark-tools` nano: 1x1 embarks are now possible in vanilla 0.40.24 + +DFHack 0.40.24-r3 +================= + +Internals +--------- +- Ruby library now included on OS X - Ruby scripts should work on OS X 10.10 +- libstdc++ should work with older versions of OS X +- Added support for `onMapLoad.init / onMapUnload.init ` scripts +- game type detection functions are now available in the World module +- The ``DFHACK_LOG_MEM_RANGES`` environment variable can be used to log information to ``stderr.log`` on OS X +- Fixed adventure mode menu names +- Fixed command usage information for some commands + +Lua +--- +- Lua scripts will only be reloaded if necessary +- Added a ``df2console()`` wrapper, useful for printing DF (CP437-encoded) text to the console in a portable way +- Added a ``strerror()`` wrapper + +New Internal Commands +--------------------- +- `hide`, `show`: hide and show the console on Windows +- `sc-script`: Allows additional scripts to be run when certain events occur (similar to `onLoad.init` scripts) + +New Plugins +----------- +- `autohauler`: A hauling-only version of autolabor + +New Scripts +----------- +- `modtools/reaction-product-trigger`: triggers callbacks when products are produced (contrast with when reactions complete) + +New Tweaks +---------- +- `fps-min `: Fixes the in-game minimum FPS setting +- `shift-8-scroll `: Gives Shift+8 (or ``*``) priority when scrolling menus, instead of scrolling the map +- `tradereq-pet-gender `: Displays pet genders on the trade request screen + +Fixes +----- +- Fixed game type detection in `3dveins`, `gui/create-item`, `reveal`, `seedwatch` +- ``PRELOAD_LIB``: More extensible on Linux +- `add-spatter`, `eventful`: Fixed crash on world load +- `add-thought`: Now has a proper subthought arg. +- `building-hacks`: Made buildings produce/consume correct amount of power +- `fix-armory`: compiles and is available again (albeit with issues) +- `gui/gm-editor`: Added search option (accessible with "s") +- `hack-wish `: Made items stack properly. +- `modtools/skill-change`: Made level granularity work properly. +- `show-unit-syndromes`: should work +- `stockflow`: + + - Fixed error message in Arena mode + - no longer checks the DF version + - fixed ballistic arrow head orders + - convinces the bookkeeper to update records more often + +- `zone`: Stopped crash when scrolling cage owner list + +Misc Improvements +----------------- +- `autolabor`: A negative pool size can be specified to use the most unskilled dwarves +- `building-hacks`: + + - Added a way to allow building to work even if it consumes more power than is available. + - Added setPower/getPower functions. + +- `catsplosion`: Can now trigger pregnancies in (most) other creatures +- `exportlegends`: ``info`` and ``all`` options export ``legends_plus.xml`` with more data for legends utilities +- `manipulator`: + + - Added ability to edit nicknames/profession names + - added "Job" as a View Type, in addition to "Profession" and "Squad" + - added custom profession templates with masking + +- `remotefortressreader`: Exposes more information + + +DFHack 0.40.24-r2 +================= + +Internals +--------- +- Lua scripts can set environment variables of each other with ``dfhack.run_script_with_env`` +- Lua scripts can now call each others internal nonlocal functions with ``dfhack.script_environment(scriptName).functionName(arg1,arg2)`` +- `eventful`: Lua reactions no longer require LUA_HOOK as a prefix; you can register a callback for the completion of any reaction with a name +- Filesystem module now provides file access/modification times and can list directories (normally and recursively) +- Units Module: New functions:: + + isWar + isHunter + isAvailableForAdoption + isOwnCiv + isOwnRace + getRaceName + getRaceNamePlural + getRaceBabyName + getRaceChildName + isBaby + isChild + isAdult + isEggLayer + isGrazer + isMilkable + isTrainableWar + isTrainableHunting + isTamable + isMale + isFemale + isMerchant + isForest + isMarkedForSlaughter + +- Buildings Module: New Functions:: + + isActivityZone + isPenPasture + isPitPond + isActive + findPenPitAt + +Fixes +----- +- ``dfhack.run_script`` should correctly find save-specific scripts now. +- `add-thought`: updated to properly affect stress. +- `hfs-pit`: should work now +- `autobutcher`: takes gelding into account +- :file:`init.lua` existence checks should be more reliable (notably when using non-English locales) + +Misc Improvements +----------------- +Multiline commands are now possible inside dfhack.init scripts. See :file:`dfhack.init-example` for example usage. + + +DFHack 0.40.24-r1 +================= + +Internals +--------- +CMake shouldn't cache DFHACK_RELEASE anymore. People may need to manually update/delete their CMake cache files to get rid of it. + + +DFHack 0.40.24-r0 +================= + +Internals +--------- +- `EventManager`: fixed crash error with EQUIPMENT_CHANGE event. +- key modifier state exposed to Lua (ie :kbd:`Ctrl`, :kbd:`Alt`, :kbd:`Shift`) + +Fixes +----- +``dfhack.sh`` can now be run from other directories on OS X + +New Plugins +----------- +- `blueprint`: export part of your fortress to quickfort .csv files + +New Scripts +----------- +- `hotkey-notes`: print key, name, and jump position of hotkeys + +Removed +------- +- needs_porting/* + +Misc Improvements +----------------- +- Added support for searching more lists + +DFHack 0.40.23-r1 +================= + +Internals +--------- +- plugins will not be loaded if globals they specify as required are not located (should prevent some crashes) + +Fixes +----- +- Fixed numerous (mostly Lua-related) crashes on OS X by including a more up-to-date libstdc++ +- :kbd:`Alt` should no longer get stuck on Windows (and perhaps other platforms as well) +- `gui/advfort` works again +- `autobutcher`: takes sexualities into account +- devel/export-dt-ini: Updated for 0.40.20+ +- `digfort`: now checks file type and existence +- `exportlegends`: Fixed map export +- `full-heal`: Fixed a problem with selecting units in the GUI +- `gui/hack-wish`: Fixed restrictive material filters +- `mousequery`: Changed box-select key to Alt+M +- `dwarfmonitor`: correct date display (month index, separator) +- `putontable`: added to the readme +- `siren` should work again +- stderr.log: removed excessive debug output on OS X +- `trackstop`: No longer prevents cancelling the removal of a track stop or roller. +- Fixed a display issue with ``PRINT_MODE:TEXT`` +- Fixed a symbol error (MapExtras::BiomeInfo::MAX_LAYERS) when compiling DFHack in Debug mode + +New Plugins +----------- +- `fortplan`: designate construction of (limited) buildings from .csv file, quickfort-style + +New Scripts +----------- +- `gui/stockpiles`: an in-game interface for saving and loading stockpile settings files. +- `position`: Reports the current date, time, month, and season, plus some location info. Port/update of position.py +- `hfs-pit`: Digs a hole to hell under the cursor. Replaces needs_porting/hellhole.cpp + +Removed +------- +- embark.lua: Obsolete, use `embark-tools` + +New tweaks +---------- +- `eggs-fertile `: Displays an egg fertility indicator on nestboxes +- `max-wheelbarrow `: Allows assigning more than 3 wheelbarrows to a stockpile + +Misc Improvements +----------------- +- `embark-tools`: Added basic mouse support on the local map +- Made some adventure mode keybindings in :file:`dfhack.init-example` only work in adventure mode +- `gui/companion-order`: added a default keybinding +- further work on needs_porting + + +DFHack 0.40.19-r1 +================= + +Fixes +----- +- `modtools/reaction-trigger`: fixed typo +- `modtools/item-trigger`: should now work with item types + +New plugins +----------- +- `savestock, loadstock `: save and load stockpile settings across worlds and saves + +New scripts +----------- +- `remove-stress`: set selected or all units unit to -1,000,000 stress (this script replaces removebadthoughts) + +Misc improvements +----------------- +- `command-prompt`: can now access selected items, units, and buildings +- `autolabor`: add an optional talent pool parameter + + +DFHack 0.40.16-r1 +================= + +Internals +--------- +- `EventManager` should handle INTERACTION triggers a little better. It still can get confused about who did what but only rarely. +- `EventManager` should no longer trigger REPORT events for old reports after loading a save. +- lua/persist-table: a convenient way of using persistent tables of arbitrary structure and dimension in Lua + +Fixes +----- +- `mousequery`: Disabled when linking levers +- `stocks`: Melting should work now +- `full-heal`: Updated with proper argument handling +- `modtools/reaction-trigger-transition`: should produce the correct syntax now +- `superdwarf`: should work better now +- `forum-dwarves`: update for new df-structures changes + +New Scripts +----------- +- `adaptation`: view or set the cavern adaptation level of your citizens +- `add-thought`: allows the user to add thoughts to creatures. +- `gaydar`: detect the sexual orientation of units on the map +- `markdown`: Save a copy of a text screen in markdown (for reddit among others). +- devel/all-bob: renames everyone Bob to help test interaction-trigger + +Misc Improvements +----------------- +- `autodump`: Can now mark a stockpile for auto-dumping (similar to `automelt` and `autotrade`) +- `buildingplan`: Can now auto-allocate rooms to dwarves with specific positions (e.g. expedition leader, mayor) +- `dwarfmonitor`: now displays a weather indicator and date +- lua/syndrome-util, `modtools/add-syndrome`: now you can remove syndromes by SYN_CLASS +- No longer write empty :file:`.history` files + + +DFHack 0.40.15-r1 +================= + +Fixes +----- +- mousequery: Fixed behavior when selecting a tile on the lowest z-level + +Misc Improvements +----------------- +- `EventManager`: deals with frame_counter getting reset properly now. +- `modtools/item-trigger`: fixed equip/unequip bug and corrected minor documentation error +- `teleport`: Updated with proper argument handling and proper unit-at-destination handling. +- `autotrade`: Removed the newly obsolete :guilabel:`Mark all` functionality. +- `search-plugin`: Adapts to the new trade screen column width +- `tweak fast-trade `: Switching the fast-trade keybinding to Shift-Up/Shift-Down, due to Select All conflict + + +DFHack 0.40.14-r1 +================= + +Internals +--------- +- The DFHack console can now be disabled by setting the DFHACK_DISABLE_CONSOLE environment variable: ``DFHACK_DISABLE_CONSOLE=1 ./dfhack`` + +Fixes +----- +- Stopped duplicate load/unload events when unloading a world +- Stopped ``-e`` from being echoed when DFHack quits on Linux +- `automelt`: now uses a faster method to locate items +- `autotrade`: "Mark all" no longer double-marks bin contents +- `drain-aquifer`: new script replaces the buggy plugin +- `embark-tools`: no longer conflicts with keys on the notes screen +- `fastdwarf`: Fixed problems with combat/attacks +- `forum-dwarves`: should work now +- `manipulator`: now uses a stable sort, allowing sorting by multiple categories +- `rendermax`: updated to work with 0.40 + +New Plugins +----------- +- `trackstop`: Shows track stop friction and dump direction in its :kbd:`q` menu + +New Tweaks +---------- +- farm-plot-select: Adds "Select all" and "Deselect all" options to farm plot menus +- import-priority-category: Allows changing the priority of all goods in a category when discussing an import agreement with the liaison +- manager-quantity: Removes the limit of 30 jobs per manager order +- civ-view-agreement: Fixes overlapping text on the "view agreement" screen +- nestbox-color: Fixes the color of built nestboxes + +Misc Improvements +----------------- +- `exportlegends`: can now handle site maps + + +DFHack 0.40.13-r1 +================= + +Internals +--------- +- unified spatter structs +- added ruby df.print_color(color, string) method for dfhack console + +Fixes +----- +- no more ``-e`` after terminating +- fixed `superdwarf` + + +DFHack 0.40.12-r1 +================= + +Internals +--------- +- support for global `onLoad.init` and `onUnload.init` files, called when loading and unloading a world +- Close file after loading a `binary patch `. + +New Plugins +----------- +- `hotkeys`: Shows in-game viewscreen with all dfhack keybindings active in current mode. +- `automelt`: allows marking stockpiles so any items placed in them will be designated for melting + +Fixes +----- +- possible crash fixed for `gui/hack-wish` +- `search-plugin`: updated to not conflict with BUILDJOB_SUSPEND +- `workflow`: job_material_category -> dfhack_material_category + +Misc Improvements +----------------- +- now you can use ``@`` to print things in interactive Lua with subtly different semantics +- optimizations for stockpiles for `autotrade` and `stockflow` +- updated `exportlegends` to work with new maps, dfhack 40.11 r1+ + + +DFHack 0.40.11-r1 +================= + +Internals +--------- +- Plugins on OS X now use ``.plug.dylib`` as an extension instead of ``.plug.so`` + +Fixes +----- +- `3dveins`: should no longer hang/crash on specific maps +- `autotrade`, `search-plugin`: fixed some layout issues +- `deathcause`: updated +- `gui/hack-wish`: should work now +- `reveal`: no longer allocates data for nonexistent map blocks +- Various documentation fixes and updates + + +DFHack v0.40.10-r1 +================== + +A few bugfixes. + +DFHack v0.40.08-r2 +================== + +Internals +--------- +- supported per save script folders +- Items module: added createItem function +- Sorted CMakeList for plugins and plugins/devel +- `diggingInvaders` no longer builds if plugin building is disabled +- `EventManager`: EQUIPMENT_CHANGE now triggers for new units. New events:: + + ON_REPORT + UNIT_ATTACK + UNLOAD + INTERACTION + +New Scripts +----------- +- lua/repeat-util: makes it easier to make things repeat indefinitely +- lua/syndrome-util: makes it easier to deal with unit syndromes +- `forum-dwarves`: helps copy df viewscreens to a file +- `full-heal`: fully heal a unit +- `remove-wear`: removes wear from all items in the fort +- `repeat`: repeatedly calls a script or a plugin +- ShowUnitSyndromes: shows syndromes affecting units and other relevant info +- `teleport`: teleports units +- `devel/print-args` +- `fix/blood-del`: makes it so civs don't bring barrels full of blood ichor or goo +- `fix/feeding-timers`: reset the feeding timers of all units +- `gui/hack-wish`: creates items out of any material +- `gui/unit-info-viewer`: displays information about units +- `modtools/add-syndrome`: add a syndrome to a unit or remove one +- `modtools/anonymous-script`: execute an lua script defined by a string. Useful for the ``*-trigger`` scripts. +- `modtools/force`: forces events: caravan, migrants, diplomat, megabeast, curiousbeast, mischievousbeast, flier, siege, nightcreature +- `modtools/item-trigger`: triggers commands based on equipping, unequipping, and wounding units with items +- `modtools/interaction-trigger`: triggers commands when interactions happen +- `modtools/invader-item-destroyer`: destroys invaders' items when they die +- `modtools/moddable-gods`: standardized version of Putnam's moddable gods script +- `modtools/projectile-trigger`: standardized version of projectileExpansion +- `modtools/reaction-trigger`: trigger commands when custom reactions complete; replaces autoSyndrome +- `modtools/reaction-trigger-transition`: a tool for converting mods from autoSyndrome to reaction-trigger +- `modtools/random-trigger`: triggers random scripts that you register +- `modtools/skill-change`: for incrementing and setting skills +- `modtools/spawn-flow`: creates flows, like mist or dragonfire +- `modtools/syndrome-trigger`: trigger commands when syndromes happen +- `modtools/transform-unit`: shapeshifts a unit, possibly permanently + +Misc improvements +----------------- +- new function in utils.lua for standardized argument processing + +Removed +------- +- digmat.rb: digFlood does the same functionality with less FPS impact +- invasionNow: `modtools/force` does it better +- autoSyndrome replaced with `modtools/reaction-trigger` +- syndromeTrigger replaced with `modtools/syndrome-trigger` +- devel/printArgs plugin converted to `devel/print-args` +- outsideOnly plugin replaced by `modtools/outside-only` + + +DFHack v0.40.08-r1 +================== + +Was a mistake. Don't use it. + +DFHack v0.34.11-r5 +================== + +Internals +--------- +- support for calling a lua function via a protobuf request (demonstrated by dfhack-run --lua). +- support for basic filesystem operations (e.g. chdir, mkdir, rmdir, stat) in C++ and Lua +- Lua API for listing files in directory. Needed for `gui/mod-manager` +- Lua API for creating unit combat reports and writing to gamelog. +- Lua API for running arbitrary DFHack commands +- support for multiple ``raw/init.d/*.lua`` init scripts in one save. +- eventful now has a more friendly way of making custom sidebars +- on Linux and OS X the console now supports moving the cursor back and forward by a whole word. + +New scripts +----------- +- `gui/mod-manager`: allows installing/uninstalling mods into df from ``df/mods`` directory. +- `gui/clone-uniform`: duplicates the currently selected uniform in the military screen. +- `fix/build-location`: partial work-around for :bug:`5991` (trying to build wall while standing on it) +- `undump-buildings`: removes dump designation from materials used in buildings. +- `exportlegends`: exports data from legends mode, allowing a set-and-forget export of large worlds. +- log-region: each time a fort is loaded identifying information will be written to the gamelog. +- `dfstatus `: show an overview of critical stock quantities, including food, drinks, wood, and bars. +- `command-prompt`: a dfhack command prompt in df. + +New plugins +----------- +- `rendermax`: replace the renderer with something else, eg ``rendermax light``- a lighting engine +- `automelt`: allows marking stockpiles for automelt (i.e. any items placed in stockpile will be designated for melting) +- `embark-tools`: implementations of Embark Anywhere, Nano Embark, and a few other embark-related utilities +- `building-hacks`: Allows to add custom functionality and/or animations to buildings. +- `petcapRemover`: triggers pregnancies in creatures so that you can effectively raise the default pet population cap +- `plant create `: spawn a new shrub under the cursor + +New tweaks +---------- +- craft-age-wear: make crafted items wear out with time like in old versions (:bug:`6003`) +- adamantine-cloth-wear: stop adamantine clothing from wearing out (:bug:`6481`) +- confirm-embark: adds a prompt before embarking (on the "prepare carefully" screen) + +Misc improvements +----------------- +- `plant`: move the 'grow', 'extirpate' and 'immolate' commands as 'plant' subcommands +- `digfort`: improved csv parsing, add start() comment handling +- `exterminate`: allow specifying a caste (exterminate gob:male) +- `createitem`: in adventure mode it now defaults to the controlled unit as maker. +- `autotrade`: adds "(Un)mark All" options to both panes of trade screen. +- `mousequery`: several usability improvements; show live overlay (in menu area) of what's on the tile under the mouse cursor. +- `search-plugin`: workshop profile search added. +- `dwarfmonitor`: add screen to summarise preferences of fortress dwarfs. +- `getplants`: add autochop function to automate woodcutting. +- `stocks`: added more filtering and display options. + +- `siege-engine`: + + - engine quality and distance to target now affect accuracy + - firing the siege engine at a target produces a combat report + - improved movement speed computation for meandering units + - operators in Prepare To Fire mode are released from duty once hungry/thirsty if there is a free replacement + + +DFHack v0.34.11-r4 +================== + +New commands +------------ +- `diggingInvaders` - allows invaders to dig and/or deconstruct walls and buildings in order to get at your dwarves. +- `digFlood` - automatically dig out specified veins as they are revealed +- `enable, disable ` - Built-in commands that can be used to enable/disable many plugins. +- `restrictice` - Restrict traffic on squares above visible ice. +- `restrictliquids` - Restrict traffic on every visible square with liquid. +- treefarm - automatically chop trees and dig obsidian + +New Scripts +----------- +- `autobutcher`: A GUI front-end for the autobutcher plugin. +- invasionNow: trigger an invasion, or many +- `locate-ore`: scan the map for unmined ore veins +- `masspit`: designate caged creatures in a zone for pitting +- `multicmd`: run a sequence of dfhack commands, separated by ';' +- `startdwarf`: change the number of dwarves for a new embark +- digmat: dig veins/layers tile by tile, as discovered + +Misc improvements +----------------- +- autoSyndrome: + + - disable by default + - reorganized special tags + - minimized error spam + - reset policies: if the target already has an instance of the syndrome you can skip, + add another instance, reset the timer, or add the full duration to the time remaining + +- core: fix SC_WORLD_(UN)LOADED event for arena mode +- `exterminate`: renamed from slayrace, add help message, add butcher mode +- `fastdwarf`: fixed bug involving fastdwarf and teledwarf being on at the same time +- magmasource: rename to `source`, allow water/magma sources/drains +- Add df.dfhack_run "somecommand" to Ruby +- syndromeTrigger: replaces and extends trueTransformation. Can trigger things when syndromes are added for any reason. +- `tiletypes`: support changing tile material to arbitrary stone. +- `workNow`: can optionally look for jobs when jobs are completed + +New tweaks +---------- +- hive-crash: Prevent crash if bees die in a hive with ungathered products (:bug:`6368`). + +New plugins +----------- +- `3dveins`: Reshapes all veins on the map in a way that flows between Z levels. May be unstable. Backup before using. +- `autotrade`: Automatically send items in marked stockpiles to trade depot, when trading is possible. +- `buildingplan`: Place furniture before it's built +- `dwarfmonitor`: Records dwarf activity to measure fort efficiency +- `mousequery`: Look and poke at the map elements with the mouse. +- outsideOnly: make raw-specified buildings impossible to build inside +- `resume`: A plugin to help display and resume suspended constructions conveniently +- `stocks`: An improved stocks display screen. + +Internals +--------- +- Core: there is now a per-save dfhack.init file for when the save is loaded, and another for when it is unloaded +- EventManager: fixed job completion detection, fixed removal of TICK events, added EQUIPMENT_CHANGE event +- Lua API for a better `random number generator ` and perlin noise functions. +- Once: easy way to make sure something happens once per run of DF, such as an error message + + +DFHack v0.34.11-r3 +================== + +Internals +--------- +- support for displaying active keybindings properly. +- support for reusable widgets in lua screen library. +- Maps::canStepBetween: returns whether you can walk between two tiles in one step. +- EventManager: monitors various in game events centrally so that individual plugins + don't have to monitor the same things redundantly. +- Now works with OS X 10.6.8 + +Notable bugfixes +---------------- +- `autobutcher` can be re-enabled again after being stopped. +- stopped `Dwarf Manipulator ` from unmasking vampires. +- `stonesense` is now fixed on OS X + +Misc improvements +----------------- +- `fastdwarf`: new mode using debug flags, and some internal consistency fixes. +- added a small stand-alone utility for applying and removing `binary patches `. +- removebadthoughts: add --dry-run option +- `superdwarf`: work in adventure mode too +- `tweak` stable-cursor: carries cursor location from/to Build menu. +- `deathcause`: allow selection from the unitlist screen +- slayrace: allow targeting undeads +- `workflow` plugin: + + - properly considers minecarts assigned to routes busy. + - code for deducing job outputs rewritten in lua for flexibility. + - logic fix: collecting webs produces silk, and ungathered webs are not thread. + - items assigned to squads are considered busy, even if not in inventory. + - shearing and milking jobs are supported, but only with generic MILK or YARN outputs. + - workflow announces when the stock level gets very low once a season. + +- Auto syndrome plugin: A way of automatically applying boiling rock syndromes and calling dfhack commands controlled by raws. +- `infiniteSky` plugin: Create new z-levels automatically or on request. +- True transformation plugin: A better way of doing permanent transformations that allows later transformations. +- `workNow` plugin: Makes the game assign jobs every time you pause. + +New tweaks +---------- +- tweak military-training: speed up melee squad training up to 10x (normally 3-5x). + +New scripts +----------- +- `binpatch`: the same as the stand-alone binpatch.exe, but works at runtime. +- region-pops: displays animal populations of the region and allows tweaking them. +- `lua`: lua interpreter front-end converted to a script from a native command. +- dfusion: misc scripts with a text based menu. +- embark: lets you embark anywhere. +- `lever`: list and pull fort levers from the dfhack console. +- `stripcaged`: mark items inside cages for dumping, eg caged goblin weapons. +- soundsense-season: writes the correct season to gamelog.txt on world load. +- create-items: spawn items +- fix/cloth-stockpile: fixes :bug:`5739`; needs to be run after savegame load every time. + +New GUI scripts +--------------- +- `gui/guide-path`: displays the cached path for minecart Guide orders. +- `gui/workshop-job`: displays inputs of a workshop job and allows tweaking them. +- `gui/workflow`: a front-end for the workflow plugin (part inspired by falconne). +- `gui/assign-rack`: works together with a binary patch to fix weapon racks. +- `gui/gm-editor`: an universal editor for lots of dfhack things. +- `gui/companion-order`: a adventure mode command interface for your companions. +- `gui/advfort`: a way to do jobs with your adventurer (e.g. build fort). + +New binary patches +------------------ +(for use with `binpatch`) + +- armorstand-capacity: doubles the capacity of armor stands. +- custom-reagent-size: lets custom reactions use small amounts of inputs. +- deconstruct-heapfall: stops some items still falling on head when deconstructing. +- deconstruct-teleport: stops items from 16x16 block teleporting when deconstructing. +- hospital-overstocking: stops hospital overstocking with supplies. +- training-ammo: lets dwarves with quiver full of combat-only ammo train. +- weaponrack-unassign: fixes bug that negates work done by gui/assign-rack. + +New Plugins +----------- +- `fix-armory`: Together with a couple of binary patches and the `gui/assign-rack` script, this plugin makes weapon racks, armor stands, chests and cabinets in properly designated barracks be used again for storage of squad equipment. +- `search-plugin`: Adds an incremental search function to the Stocks, Trading, Stockpile and Unit List screens. +- `automaterial`: Makes building constructions (walls, floors, fortifications, etc) a little bit easier by saving you from having to trawl through long lists of materials each time you place one. +- Dfusion: Reworked to make use of lua modules, now all the scripts can be used from other scripts. +- Eventful: A collection of lua events, that will allow new ways to interact with df world. + +DFHack v0.34.11-r2 +================== + +Internals +--------- +- full support for Mac OS X. +- a plugin that adds scripting in `ruby `. +- support for interposing virtual methods in DF from C++ plugins. +- support for creating new interface screens from C++ and lua. +- added various other API functions. + +Notable bugfixes +---------------- +- better terminal reset after exit on linux. +- `seedwatch` now works on reclaim. +- the sort plugin won't crash on cages anymore. + +Misc improvements +----------------- +- `autodump`: can move items to any walkable tile, not just floors. +- `stripcaged`: by default keep armor, new dumparmor option. +- `zone`: allow non-domesticated birds in nestboxes. +- `workflow`: quality range in constraints. +- cleanplants: new command to remove rain water from plants. +- `liquids`: can paint permaflow, i.e. what makes rivers power water wheels. +- `prospect`: pre-embark prospector accounts for caves & magma sea in its estimate. +- `rename`: supports renaming stockpiles, workshops, traps, siege engines. +- `fastdwarf`: now has an additional option to make dwarves teleport to their destination. +- `autolabor`: + + - can set nonidle hauler percentage. + - broker excluded from all labors when needed at depot. + - likewise, anybody with a scheduled diplomat meeting. + +New commands +------------ +- misery: multiplies every negative thought gained (2x by default). +- `digtype`: designates every tile of the same type of vein on the map for 'digging' (any dig designation). + +New tweaks +---------- +- tweak stable-cursor: keeps exact cursor position between d/k/t/q/v etc menus. +- tweak patrol-duty: makes Train orders reduce patrol timer, like the binary patch does. +- tweak readable-build-plate: fix unreadable truncation in unit pressure plate build ui. +- tweak stable-temp: fixes bug 6012; may improve FPS by 50-100% on a slow item-heavy fort. +- tweak fast-heat: speeds up item heating & cooling, thus making stable-temp act faster. +- tweak fix-dimensions: fixes subtracting small amounts from stacked liquids etc. +- tweak advmode-contained: fixes UI bug in custom reactions with container inputs in advmode. +- tweak fast-trade: Shift-Enter for selecting items quickly in Trade and Move to Depot screens. +- tweak military-stable-assign: Stop rightmost list of military->Positions from jumping to top. +- tweak military-color-assigned: In same list, color already assigned units in brown & green. + +New scripts +----------- +- `fixnaked`: removes thoughts about nakedness. +- `setfps`: set FPS cap at runtime, in case you want slow motion or speed-up. +- `siren`: wakes up units, stops breaks and parties - but causes bad thoughts. +- `fix/population-cap`: run after every migrant wave to prevent exceeding the cap. +- `fix/stable-temp`: counts items with temperature updates; does instant one-shot stable-temp. +- `fix/loyaltycascade`: fix units allegiance, eg after ordering a dwarf merchant kill. +- `deathcause`: shows the circumstances of death for a given body. +- `digfort`: designate areas to dig from a csv file. +- `drain-aquifer`: remove aquifers from the map. +- `growcrops`: cheat to make farm crops instantly grow. +- magmasource: continuously spawn magma from any map tile. +- removebadthoughts: delete all negative thoughts from your dwarves. +- slayrace: instakill all units of a given race, optionally with magma. +- `superdwarf`: per-creature `fastdwarf`. +- `gui/mechanisms`: browse mechanism links of the current building. +- `gui/room-list`: browse other rooms owned by the unit when assigning one. +- `gui/liquids`: a GUI front-end for the liquids plugin. +- `gui/rename`: renaming stockpiles, workshops and units via an in-game dialog. +- `gui/power-meter`: front-end for the Power Meter plugin. +- `gui/siege-engine`: front-end for the Siege Engine plugin. +- `gui/choose-weapons`: auto-choose matching weapons in the military equip screen. + +New Plugins +----------- +- `manipulator`: a Dwarf Therapist like UI in the game (:kbd:`u`:kbd:`l`) +- `steam-engine`: an alternative to Water Reactors which make more sense. + See ``hack/raw/*_steam_engine.txt`` for the necessary raw definitions. +- `power-meter`: a pressure plate modification to detect powered gear + boxes on adjacent tiles. `gui/power-meter` implements + the build configuration UI. +- `siege-engine`: massive overhaul for siege engines, configured via `gui/siege-engine` +- `add-spatter`: allows poison coatings via raw reactions, among other things. diff --git a/docs/about/Removed.rst b/docs/about/Removed.rst new file mode 100644 index 0000000000..bf3d0118df --- /dev/null +++ b/docs/about/Removed.rst @@ -0,0 +1,406 @@ +############# +Removed tools +############# + +This page lists tools (plugins or scripts) that were previously included in +DFHack but have been removed. It exists primarily so that internal links still +work (e.g. links from the `changelog`). + +.. contents:: Contents + :local: + :depth: 1 + +.. _adv-rumors: + +adv-rumors +========== +Converted to an `overlay` and merged into `advtools`. + +.. _adv-fix-sleepers: + +adv-fix-sleepers +================ +Renamed to `fix/sleepers`. + +.. _autohauler: + +autohauler +========== +An automated labor management tool that only addressed hauling labors, leaving the assignment +of skilled labors entirely up to the player. Fundamentally incompatible with the work detail +system of labor management in v50 of Dwarf Fortress. + +.. _automaterial: + +automaterial +============ +Moved frequently used materials to the top of the materials list when building +buildings. Also offered extended options when building constructions. All +functionality has been merged into `buildingplan`. + +.. _automelt: + +automelt +======== +Automatically mark items for melting when they are brought to a monitored +stockpile. Merged into `logistics`. + +.. _autotrade: + +autotrade +========= +Automatically mark items for trading when they are brought to a monitored +stockpile. Merged into `logistics`. + +.. _autounsuspend: + +autounsuspend +============= +Replaced by `suspendmanager`. + +.. _combine-drinks: + +combine-drinks +============== +Replaced by the new `combine` script. Run +``combine here --types=drink`` + +.. _combine-plants: + +combine-plants +============== +Replaced by the new `combine` script. Run +``combine here --types=plants`` + +.. _command-prompt: + +command-prompt +============== +Replaced by `gui/launcher --minimal `. + +.. _create-items: + +create-items +============ +Replaced by `gui/create-item`. + +.. _deteriorateclothes: + +deteriorateclothes +================== +Replaced by the new combined `deteriorate` script. Run +``deteriorate --types=clothes``. + +.. _deterioratecorpses: + +deterioratecorpses +================== +Replaced by the new combined `deteriorate` script. Run +``deteriorate --types=corpses``. + +.. _deterioratefood: + +deterioratefood +=============== +Replaced by the new combined `deteriorate` script. Run +``deteriorate --types=food``. + +.. _devel/find-offsets: + +devel/find-offsets +================== +Used in pre-v50 times for memory structure analysis. No longer useful post-v50. + +.. _devel/find-twbt: + +devel/find-twbt +=============== +Used in pre-v50 times for memory structure analysis. No longer useful post-v50. + +.. _devel/prepare-save: + +devel/prepare-save +================== +Used in pre-v50 times for memory structure analysis. No longer useful post-v50. + +.. _devel/unforbidall: + +devel/unforbidall +================= +Replaced by the `unforbid` script. Run ``unforbid all --quiet`` to match the +behavior of the original ``devel/unforbidall`` script. + +.. _digfort: + +digfort +======= +A script to designate an area for digging according to a plan in csv format. +Please use DFHack's more powerful `quickfort` script instead. You can use your +existing .csv files. Just move them to the ``blueprints`` folder in your DF +installation, and instead of ``digfort file.csv``, run +``quickfort run file.csv``. + +.. _drain-aquifer: + +drain-aquifer +============= +Replaced by `aquifer` and `gui/aquifer`. + +.. _embark-tools: + +embark-tools +============ +Replaced by `gui/embark-anywhere`. Other functionality was replaced by the DF +v50 UI. + +.. _faststart: + +faststart +========= +Sped up the initial DF load sequence. Removed since Bay 12 rewrote the startup +sequence and it is now sufficiently fast on its own. + +.. _fix-armory: + +fix-armory +========== +Allowed the military to store equipment in barracks containers. Removed because +it required a binary patch to DF in order to function, and no such patch has +existed since DF 0.34.11. + +.. _fix/build-location: + +fix/build-location +================== +The corresponding DF :bug:`5991` was fixed in DF 0.40.05. + +.. _fix/diplomats: + +fix/diplomats +============= +The corresponding DF :bug:`3295` was fixed in DF 0.40.05. + +.. _fix/fat-dwarves: + +fix/fat-dwarves +=============== +The corresponding DF :bug:`5971` was fixed in DF 0.40.05. + +.. _fix/feeding-timers: + +fix/feeding-timers +================== +The corresponding DF :bug:`2606` was fixed in DF 0.40.12. + +.. _fix/item-occupancy: + +fix/item-occupancy +================== +Merged into `fix/occupancy`. + +.. _fix/merchants: + +fix/merchants +============= +Humans can now make trade agreements. This fix is no longer necessary. + +.. _fix/tile-occupancy: + +fix/tile-occupancy +================== +Merged into `fix/occupancy`. + +.. _fix-unit-occupancy: + +fix-unit-occupancy +================== +Merged into `fix/occupancy`. + +.. _fortplan: + +fortplan +======== +Designates furniture for building according to a ``.csv`` file with +quickfort-style syntax. Please use DFHack's more powerful `quickfort` +script instead. You can use your existing .csv files. Just move them to the +``blueprints`` folder in your DF installation, and instead of +``fortplan file.csv`` run ``quickfort run file.csv``. + +.. _gui/assign-rack: + +gui/assign-rack +=============== +This script is no longer useful in current DF versions. The script required a +binpatch `, which has not been available since DF +0.34.11. + +.. _gui/automelt: + +gui/automelt +============ +Replaced by the `stockpiles` overlay and the gui for `logistics`. + +.. _gui/create-tree: + +gui/create-tree +=============== +Replaced by `gui/sandbox`. + +.. _gui/dig: + +gui/dig +======= +Renamed to `gui/design`. + +.. _gui/hack-wish: + +gui/hack-wish +============= +Replaced by `gui/create-item`. + +.. _gui/logcleaner: + +gui/logcleaner +============== +Removed because changes to Dwarf Fortress internals made the functionality +impossible to implement safely. + +.. _gui/manager-quantity: + +gui/manager-quantity +==================== +Ability to modify manager order quantities has been added to the vanilla UI. + +.. _gui/mechanisms: + +gui/mechanisms +============== +Linked building interface has been added to the vanilla UI. + +.. _gui/no-dfhack-init: + +gui/no-dfhack-init +================== +Tool that warned the user when the ``dfhack.init`` file did not exist. Now that +``dfhack.init`` is autogenerated in ``dfhack-config/init``, this warning is no +longer necessary. + +.. _logcleaner: + +logcleaner +=============== +Removed because changes to Dwarf Fortress internals made the functionality +impossible to implement safely. + +.. _masspit: + +masspit +======= +Replaced with a GUI version: `gui/masspit`. + +.. _max-wave: + +max-wave +======== +Set population cap based on parameters. Merged into `pop-control`. + +.. _modtools/force: + +modtools/force +============== +Merged into `force`. + +.. _mousequery: + +mousequery +========== +Functionality superseded by vanilla v50 interface. + +.. _petcapRemover: + +petcapRemover +============= +Renamed to `pet-uncapper`. + +.. _plants: + +plants +====== +Renamed to `plant`. + +.. _rename: + +rename +====== +Superseded by vanilla rename capabilities and `gui/rename`. + +.. _resume: + +resume +====== +Allowed you to resume suspended jobs and displayed an overlay indicating +suspended building construction jobs. Replaced by `unsuspend` script. + +.. _ruby: +.. _rb: + +ruby +==== +Support for the Ruby language in DFHack scripts was removed due to the issues +the Ruby library causes when used as an embedded language. + +.. _search-plugin: + +search +====== +Functionality was merged into `sort`. + +.. _show-unit-syndromes: + +show-unit-syndromes +=================== +Replaced with a GUI version: `gui/unit-syndromes`. + +.. _stocksettings: + +stocksettings +============= +Along with ``copystock``, ``loadstock`` and ``savestock``, replaced with the new +`stockpiles` API. + +.. _title-version: + +title-version +============= +Replaced with an `overlay`. + +.. _unsuspend: + +unsuspend +========= +Merged into `suspendmanager`. + +.. _warn-starving: + +warn-starving +============= +Functionality was merged into `gui/notify`. + +.. _warn-stealers: + +warn-stealers +============= +Functionality was merged into `gui/notify`. + +.. _warn-stuck-trees: + +warn-stuck-trees +================ +The corresponding DF :bug:`9252` was fixed in DF 0.44.01. + +.. _workorder-recheck: + +workorder-recheck +================= +Tool to set 'Checking' status of the selected work order, allowing conditions +to be reevaluated. Merged into `orders`. diff --git a/docs/about/index.rst b/docs/about/index.rst new file mode 100644 index 0000000000..e8dede969c --- /dev/null +++ b/docs/about/index.rst @@ -0,0 +1,13 @@ +============ +About DFHack +============ + +These pages contain information about the general DFHack project. + +.. toctree:: + :maxdepth: 1 + + /docs/about/Authors + /LICENSE + /docs/about/Removed + /docs/NEWS diff --git a/docs/api/Maps.rst b/docs/api/Maps.rst new file mode 100644 index 0000000000..f6a0a98826 --- /dev/null +++ b/docs/api/Maps.rst @@ -0,0 +1,59 @@ +.. include:: + +======== +Maps API +======== + +DFHack offers several ways to access and manipulate map data. + +* C++: the ``Maps`` and ``MapCache`` modules +* Lua: the `dfhack.maps module` +* All languages: the ``map`` field of the ``world`` global contains raw map data + when the world is loaded. + +.. note:: + + This page will eventually go into more detail about the available APIs. + For now, it is just an overview of how DF map data is structured. + +.. contents:: Contents + :local: + +Tiles +===== + +The DF map has several types of tiles: + +- **Local tiles** are at the smallest scale. In regular fortress/adventure mode + play, the cursor takes up 1 local tile. + + Objects that use local tile coordinates include: + + - Units + - Items + - Projectiles + +- **Blocks** are 16 |times| 16 |times| 1 groups of local tiles. Internally, many + tile details are stored at the block level for space-efficiency reasons. + Blocks are visible during zoomed-in fast travel in adventure mode. + + Objects that use block coordinates include: + + - Armies + +- **Region tiles** are 3 |times| 3 groups of columns of blocks (they span the + entire z-axis), or 48 |times| 48 columns of local tiles. DF sometimes refers + to these as "mid-level tiles" (MLTs). Region tiles are visible when resizing + a fortress before embarking, or in zoomed-out fast travel in adventure mode. + +- **World tiles** are + + - 16 |times| 16 groups of region tiles, or + - 48 |times| 48 groups of columns of blocks, or + - 768 |times| 768 groups of columns of local tiles + + World tiles are visible on the world map before embarking, as well as in the + civilization map in fortress mode and the quest log in adventure mode. + +- Some map features are stored in 16 |times| 16 groups of world tiles, sometimes + referred to as "feature shells". diff --git a/docs/api/index.rst b/docs/api/index.rst new file mode 100644 index 0000000000..e0748be2c5 --- /dev/null +++ b/docs/api/index.rst @@ -0,0 +1,8 @@ +=================== +DFHack API concepts +=================== + +.. toctree:: + :maxdepth: 1 + + /docs/api/Maps diff --git a/docs/build.py b/docs/build.py new file mode 100755 index 0000000000..bf0dd9e488 --- /dev/null +++ b/docs/build.py @@ -0,0 +1,106 @@ +#!/usr/bin/env python3 + +# for help, run: python3 build.py --help + +import argparse +import os +import subprocess +import sys + +class SphinxOutputFormat: + def __init__(self, name, pre_args): + self.name = str(name) + self.pre_args = tuple(pre_args) + + @property + def args(self): + output_dir = os.path.join('docs', self.name) + artifacts_dir = os.path.join('build', 'docs', self.name) # for artifacts not part of the final documentation + os.makedirs(artifacts_dir, mode=0o755, exist_ok=True) + return [ + *self.pre_args, + '.', # source dir + output_dir, + '-d', artifacts_dir, + '-w', os.path.join(artifacts_dir, 'sphinx-warnings.txt'), + ] + +OUTPUT_FORMATS = { + 'html': SphinxOutputFormat('html', pre_args=['-b', 'html']), + 'text': SphinxOutputFormat('text', pre_args=['-b', 'text']), + 'pdf': SphinxOutputFormat('pdf', pre_args=['-M', 'latexpdf']), + 'xml': SphinxOutputFormat('xml', pre_args=['-b', 'xml']), + 'pseudoxml': SphinxOutputFormat('pseudoxml', pre_args=['-b', 'pseudoxml']), +} + +def _parse_known_args(parser, source_args): + # pass along any arguments after '--' + ignored_args = [] + if '--' in source_args: + source_args, ignored_args = source_args[:source_args.index('--')], source_args[source_args.index('--')+1:] + args, forward_args = parser.parse_known_args(source_args) + forward_args += ignored_args + return args, forward_args + +def parse_args(source_args): + def output_format(s): + if s in OUTPUT_FORMATS: + return s + raise ValueError + + parser = argparse.ArgumentParser(usage='%(prog)s [{} ...] [options] [--] [sphinx_options]'.format('|'.join(OUTPUT_FORMATS.keys())), description=''' + DFHack wrapper around sphinx-build. + + Any unrecognized options are passed directly to sphinx-build, as well as any + options following a '--' argument, if specified. + ''') + parser.add_argument('format', nargs='*', type=output_format, action='append', + help='Documentation format(s) to build - choose from {}'.format(', '.join(OUTPUT_FORMATS.keys()))) + parser.add_argument('-E', '--clean', action='store_true', + help='Re-read all input files') + parser.add_argument('--sphinx', type=str, default=os.environ.get('SPHINX', 'sphinx-build'), + help='Sphinx executable to run [environment variable: SPHINX; default: "sphinx-build"]') + parser.add_argument('-j', '--jobs', type=str, default=os.environ.get('JOBS', 'auto'), + help='Number of Sphinx threads to run [environment variable: JOBS; default: "auto"]') + parser.add_argument('-q', '--quiet', action='store_true', + help='Disable most output on stdout (also passed to sphinx-build)') + parser.add_argument('--debug', action='store_true', + help='Log commands that are run, etc.') + parser.add_argument('--offline', action='store_true', + help='Disable network connections') + args, forward_args = _parse_known_args(parser, source_args) + + # work around weirdness with list args + args.format = args.format[0] + if not args.format: + args.format = ['html'] + + return args, forward_args + +if __name__ == '__main__': + os.chdir(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + if not os.path.isfile('conf.py'): + print('Could not find conf.py', file=sys.stderr) + exit(1) + + args, forward_args = parse_args(sys.argv[1:]) + + sphinx_env = os.environ.copy() + if args.offline: + sphinx_env['DFHACK_DOCS_BUILD_OFFLINE'] = '1' + + for format_name in args.format: + command = [args.sphinx] + OUTPUT_FORMATS[format_name].args + ['-j', args.jobs] + if args.clean: + command += ['-E'] + if args.quiet: + command += ['-q'] + command += forward_args + + if args.debug: + print('Building:', format_name) + print('Running:', command) + subprocess.run(command, check=True, env=sphinx_env) + + if not args.quiet: + print('') diff --git a/docs/builtins/alias.rst b/docs/builtins/alias.rst new file mode 100644 index 0000000000..69ca42ba0d --- /dev/null +++ b/docs/builtins/alias.rst @@ -0,0 +1,36 @@ +alias +===== + +.. dfhack-tool:: + :summary: Configure helper aliases for other DFHack commands. + :tags: dfhack + +Aliases are resolved immediately after built-in commands, which means that an +alias cannot override a built-in command, but can override a command implemented +by a plugin or script. + +Usage +----- + +``alias list`` + Lists all configured aliases +``alias add [arguments...]`` + Adds an alias +``alias replace [arguments...]`` + Replaces an existing alias with a new command, or adds the alias if it does + not already exist +``alias delete `` + Removes the specified alias + +Aliases can be given additional arguments when created and invoked, which will +be passed to the underlying command in order. + +Example +------- + +:: + + [DFHack]# alias add pargs devel/print-args example + [DFHack]# pargs text + example + text diff --git a/docs/builtins/cls.rst b/docs/builtins/cls.rst new file mode 100644 index 0000000000..a5fc391cdd --- /dev/null +++ b/docs/builtins/cls.rst @@ -0,0 +1,16 @@ +cls +=== + +.. dfhack-tool:: + :summary: Clear the terminal screen. + :tags: dfhack + +Can also be invoked as ``clear``. Note that this command does not delete command +history. It just clears the text on the screen. + +Usage +----- + +:: + + cls diff --git a/docs/builtins/devel/dump-rpc.rst b/docs/builtins/devel/dump-rpc.rst new file mode 100644 index 0000000000..957233b628 --- /dev/null +++ b/docs/builtins/devel/dump-rpc.rst @@ -0,0 +1,15 @@ +devel/dump-rpc +============== + +.. dfhack-tool:: + :summary: Dump RPC endpoint info. + :tags: dev + +Write RPC endpoint information to the specified file. + +Usage +----- + +:: + + devel/dump-rpc diff --git a/docs/builtins/die.rst b/docs/builtins/die.rst new file mode 100644 index 0000000000..3b9a083802 --- /dev/null +++ b/docs/builtins/die.rst @@ -0,0 +1,15 @@ +die +=== + +.. dfhack-tool:: + :summary: Instantly exit DF without saving. + :tags: dfhack + +Use to exit DF quickly and safely. + +Usage +----- + +:: + + die diff --git a/docs/builtins/disable.rst b/docs/builtins/disable.rst new file mode 100644 index 0000000000..7c64f4b39e --- /dev/null +++ b/docs/builtins/disable.rst @@ -0,0 +1,15 @@ +disable +======= + +.. dfhack-tool:: + :summary: Deactivate a DFHack tool that has some persistent effect. + :tags: dfhack + +See the `enable` command for more info. + +Usage +----- + +:: + + disable [ ...] diff --git a/docs/builtins/enable.rst b/docs/builtins/enable.rst new file mode 100644 index 0000000000..8525214b3c --- /dev/null +++ b/docs/builtins/enable.rst @@ -0,0 +1,36 @@ +enable +====== + +.. dfhack-tool:: + :summary: Activate a DFHack tool that has some persistent effect. + :tags: dfhack + +Many plugins and scripts can be in a distinct enabled or disabled state. Some +of them activate and deactivate automatically depending on the contents of the +world raws. Others store their state in world data. However a number of them +have to be enabled globally, and the init file is the right place to do it. + +Most such plugins or scripts support the built-in ``enable`` and `disable` +commands. Calling them at any time without arguments prints a list of enabled +and disabled plugins, and shows whether that can be changed through the same +commands. Passing plugin names to these commands will enable or disable the +specified plugins. + +If you are a script developer, see `script-enable-api` for how to expose whether +your script is currently enabled or disabled. + +Usage +----- + +:: + + enable + enable [ ...] + +Examples +-------- + +``enable manipulator`` + Enable the ``manipulator`` plugin. +``enable manipulator search`` + Enable multiple plugins at once. diff --git a/docs/builtins/fpause.rst b/docs/builtins/fpause.rst new file mode 100644 index 0000000000..ed5a40cad1 --- /dev/null +++ b/docs/builtins/fpause.rst @@ -0,0 +1,15 @@ +fpause +====== + +.. dfhack-tool:: + :summary: Forces DF to pause. + :tags: dfhack + +This is useful when your FPS drops below 1 and you lose control of the game. + +Usage +----- + +:: + + fpause diff --git a/docs/builtins/help.rst b/docs/builtins/help.rst new file mode 100644 index 0000000000..a744e8d69c --- /dev/null +++ b/docs/builtins/help.rst @@ -0,0 +1,29 @@ +help +==== + +.. dfhack-tool:: + :summary: Display help about a command or plugin. + :tags: dfhack + +Can also be invoked as ``?`` or ``man`` (short for "manual"). + +Usage +----- + +:: + + help|?|man + help|?|man + +Examples +-------- + +:: + + help blueprint + man blueprint + +Both examples above will display the help text for the `blueprint` command. + +Some commands also take ``help`` or ``?`` as an option on their command line +for the same effect -- e.g. ``blueprint help``. diff --git a/docs/builtins/hide.rst b/docs/builtins/hide.rst new file mode 100644 index 0000000000..037679d69c --- /dev/null +++ b/docs/builtins/hide.rst @@ -0,0 +1,18 @@ +hide +==== + +.. dfhack-tool:: + :summary: Hide the DFHack terminal window. + :tags: dfhack + +You can show it again with the `show` command, though you'll need to use it from +a `keybinding` set beforehand or the in-game `command-prompt`. + +Only available on Windows. + +Usage +----- + +:: + + hide diff --git a/docs/builtins/keybinding.rst b/docs/builtins/keybinding.rst new file mode 100644 index 0000000000..e8f206848d --- /dev/null +++ b/docs/builtins/keybinding.rst @@ -0,0 +1,84 @@ +keybinding +========== + +.. dfhack-tool:: + :summary: Create hotkeys that will run DFHack commands. + :tags: dfhack + +Like any other command, it can be used at any time from the console, but +bindings are not remembered between runs of the game unless re-created in +:file:`dfhack-config/init/dfhack.init`. + +Hotkeys can be any combinations of Ctrl/Alt/Super/Shift with any key recognized by SDL. +You can also represent mouse buttons beyond the first three with ``MOUSE4`` +through ``MOUSE15``. + +Usage +----- + +``keybinding`` + Show some useful information, including the current game context. +``keybinding list `` + List bindings active for the key combination. +``keybinding clear [...]`` + Remove bindings for the specified keys. +``keybinding add "" ["" ...]`` + Add bindings for the specified key. +``keybinding set "" ["" ...]`` + Clear, and then add bindings for the specified key. + +The ```` parameter above has the following case-insensitive syntax:: + + [Ctrl-][Alt-][Super-][Shift-]KEY[@context[|context...]] + +where the ``KEY`` part can be any recognized key and :kbd:`[`:kbd:`]` denote +optional parts. It is important to note that the key is the non-shifted version +of the key. For example ``!`` would be defined as ``Shift-0``. + +DFHack commands can advertise the contexts in which they can be usefully run. +For example, a command that acts on a selected unit can tell `keybinding` that +it is not "applicable" in the current context if a unit is not actively +selected. + +When multiple commands are bound to the same key combination, DFHack selects +the first applicable one. Later ``add`` commands, and earlier entries within one +``add`` command have priority. Commands that are not specifically intended for +use as a hotkey are always considered applicable. + +The ``context`` part in the key specifier above can be used to explicitly +restrict the UI state where the binding would be applicable. + +Only bindings with a ``context`` tag that either matches the current context +fully, or is a prefix ending at a ``/`` boundary would be considered for +execution, i.e. when in context ``foo/bar/baz``, keybindings restricted to any +of ``@foo/bar/baz``, ``@foo/bar``, ``@foo``, or none will be active. + +Multiple contexts can be specified by separating them with a pipe (``|``) - for +example, ``@foo|bar|baz/foo`` would match anything under ``@foo``, ``@bar``, or +``@baz/foo``. + +Commands like `liquids` or `tiletypes` cannot be used as hotkeys since they +require the console for interactive input. + +Examples +-------- + +Bind Ctrl-Shift-C to run the `hotkeys` command on any screen at any time:: + + keybinding add Ctrl-Shift-C hotkeys + +Bind Ctrl-M to run `gui/mass-remove`, but only when on the main map with +nothing else selected:: + + keybinding add Ctrl-M@dwarfmode/Default gui/mass-remove + +Bind the fourth mouse button to launch `gui/teleport` when a unit is selected +or `gui/autodump` when an item is selected:: + + keybinding add MOUSE4@dwarfmode/ViewSheets/UNIT gui/teleport + keybinding add MOUSE4@dwarfmode/ViewSheets/ITEM gui/autodump + +Bind Shift + the fifth mouse button to toggle the keyboard cursor in fort or +adventure mode:: + + keybinding add Shift-MOUSE5@dwarfmode|dungeonmode toggle-kbd-cursor diff --git a/docs/builtins/kill-lua.rst b/docs/builtins/kill-lua.rst new file mode 100644 index 0000000000..4cb3e203c4 --- /dev/null +++ b/docs/builtins/kill-lua.rst @@ -0,0 +1,18 @@ +kill-lua +======== + +.. dfhack-tool:: + :summary: Gracefully stop any currently-running Lua scripts. + :tags: dfhack + +Use this command to stop a misbehaving script that appears to be stuck. + +Usage +----- + +:: + + kill-lua + kill-lua force + +Use ``kill-lua force`` if just ``kill-lua`` doesn't seem to work. diff --git a/docs/builtins/load.rst b/docs/builtins/load.rst new file mode 100644 index 0000000000..a913162625 --- /dev/null +++ b/docs/builtins/load.rst @@ -0,0 +1,19 @@ +load +==== + +.. dfhack-tool:: + :summary: Load and register a plugin library. + :tags: dfhack + +Also see `unload` and `reload` for related actions. + +Usage +----- + +:: + + load [ ...] + load -a|--all + +You can load individual named plugins or all plugins at once. Note that plugins +are disabled after loading/reloading until you explicitly `enable` them. diff --git a/docs/builtins/ls.rst b/docs/builtins/ls.rst new file mode 100644 index 0000000000..cd6bc41261 --- /dev/null +++ b/docs/builtins/ls.rst @@ -0,0 +1,44 @@ +ls +== + +.. dfhack-tool:: + :summary: List available DFHack commands. + :tags: dfhack + +In order to group related commands, each command is associated with a list of +tags. You can filter the listed commands by a tag or a substring of the +command name. Can also be invoked as ``dir``. + +Usage +----- + +``ls []`` + Lists all available commands and the tags associated with them. +``ls []`` + Shows only commands that have the given tag. Use the `tags` command to see + the list of available tags. +``ls []`` + Shows commands that include the given string. E.g. ``ls quick`` will show + all the commands with "quick" in their names. If the string is also the + name of a tag, then it will be interpreted as a tag name. + +Examples +-------- + +``ls quick`` + List all commands that match the substring "quick". +``ls adventure`` + List all commands with the ``adventure`` tag. +``ls --dev trigger`` + List all commands, including developer and modding commands, that match the + substring "trigger". + +Options +------- + +``--notags`` + Don't print out the tags associated with each command. +``--dev`` + Include commands intended for developers and modders. +``--exclude [,...]`` + Exclude commands that match any of the given strings. diff --git a/docs/builtins/plug.rst b/docs/builtins/plug.rst new file mode 100644 index 0000000000..8df378d3c8 --- /dev/null +++ b/docs/builtins/plug.rst @@ -0,0 +1,16 @@ +plug +==== + +.. dfhack-tool:: + :summary: List available plugins and whether they are enabled. + :tags: dfhack + +Usage +----- + +:: + + plug [ [ ...]] + +If run with parameters, it lists only the named plugins. Otherwise it will list +all available plugins. diff --git a/docs/builtins/reload.rst b/docs/builtins/reload.rst new file mode 100644 index 0000000000..9ee9061a2b --- /dev/null +++ b/docs/builtins/reload.rst @@ -0,0 +1,21 @@ +reload +====== + +.. dfhack-tool:: + :summary: Reload a loaded plugin. + :tags: dfhack + +Developers use this command to reload a plugin that they are actively modifying. +Also see `load` and `unload` for related actions. + +Usage +----- + +:: + + reload [ ...] + reload -a|--all + +You can reload individual named plugins or all plugins at once. Note that +plugins are disabled after loading/reloading until you explicitly `enable` +them. diff --git a/docs/builtins/sc-script.rst b/docs/builtins/sc-script.rst new file mode 100644 index 0000000000..f66aeb412c --- /dev/null +++ b/docs/builtins/sc-script.rst @@ -0,0 +1,26 @@ +sc-script +========= + +.. dfhack-tool:: + :summary: Run commands when game state changes occur. + :tags: dfhack + +This is similar to the static `init-files` but is slightly more flexible since +it can be set dynamically. + +Usage +----- + +``sc-script [help]`` + Show the list of valid event names. +``sc-script list []`` + List the currently registered files for all events or the specified event. +``sc-script add|remove [ ...]`` + Register or unregister a file to be run for the specified event. + +Example +------- + +``sc-script add SC_MAP_LOADED spawn_extra_monsters.init`` + Registers the ``spawn_extra_monsters.init`` file to be run whenever a new + map is loaded. diff --git a/docs/builtins/script.rst b/docs/builtins/script.rst new file mode 100644 index 0000000000..0c4ca8c3d5 --- /dev/null +++ b/docs/builtins/script.rst @@ -0,0 +1,26 @@ +script +====== + +.. dfhack-tool:: + :summary: Execute a batch file of DFHack commands. + :tags: dfhack + +It reads a text file and runs each line as a DFHack command as if it had been +typed in by the user -- treating the input like `an init file `. + +Some other tools, such as `autobutcher` and `workflow`, export their settings as +the commands to create them - which can later be reloaded with ``script``. + +Usage +----- + +:: + + script + +Example +------- + +``script startup.txt`` + Executes the commands in ``startup.txt``, which exists in your DF game + directory. diff --git a/docs/builtins/show.rst b/docs/builtins/show.rst new file mode 100644 index 0000000000..cbfa3a386d --- /dev/null +++ b/docs/builtins/show.rst @@ -0,0 +1,19 @@ +show +==== + +.. dfhack-tool:: + :summary: Unhides the DFHack terminal window. + :tags: dfhack + +Useful if you have hidden the terminal with `hide` and you want it back. Since +the terminal window won't be available to run this command, you'll need to use +it from a `keybinding` set beforehand or the in-game `command-prompt`. + +Only available on Windows. + +Usage +----- + +:: + + show diff --git a/docs/builtins/tags.rst b/docs/builtins/tags.rst new file mode 100644 index 0000000000..698323ffe6 --- /dev/null +++ b/docs/builtins/tags.rst @@ -0,0 +1,26 @@ +tags +==== + +.. dfhack-tool:: + :summary: List the categories of DFHack tools or the tools with those tags. + :tags: dfhack + +DFHack tools are labeled with tags so you can find groups of related commands. +This builtin command lists the tags that you can explore, or, if called with the +name of a tag, lists the tools that have that tag. + +Usage +----- + +``tags`` + List the categories of DFHack tools and a description of those categories. +``tags `` + List the tools that are tagged with the given tag. + +Examples +-------- + +``tags`` + List the defined tags. +``tags design`` + List all the tools that have the ``design`` tag. diff --git a/docs/builtins/type.rst b/docs/builtins/type.rst new file mode 100644 index 0000000000..1bf86e588c --- /dev/null +++ b/docs/builtins/type.rst @@ -0,0 +1,17 @@ +type +==== + +.. dfhack-tool:: + :summary: Describe how a command is implemented. + :tags: dfhack + +DFHack commands can be provided by plugins, scripts, or by the core library +itself. The ``type`` command can tell you which is the source of a particular +command. + +Usage +----- + +:: + + type diff --git a/docs/builtins/unload.rst b/docs/builtins/unload.rst new file mode 100644 index 0000000000..6fa52ea9e0 --- /dev/null +++ b/docs/builtins/unload.rst @@ -0,0 +1,18 @@ +unload +====== + +.. dfhack-tool:: + :summary: Unload a plugin from memory. + :tags: dfhack + +Also see `load` and `reload` for related actions. + +Usage +----- + +:: + + unload [ ...] + unload -a|--all + +You can unload individual named plugins or all plugins at once. diff --git a/docs/changelog-placeholder.txt b/docs/changelog-placeholder.txt new file mode 100644 index 0000000000..86ffbcaeb6 --- /dev/null +++ b/docs/changelog-placeholder.txt @@ -0,0 +1,11 @@ +DFHack's changelog is no longer stored at this location. + +- For a local copy, see hack/docs/docs/NEWS.html + (this requires offline docs to be installed) +- For an online copy, see https://dfhack.readthedocs.org/en/stable/docs/NEWS.html + + +--- + +Note to maintainers: this file is installed to hack/changelog.txt - for details, +see https://github.com/DFHack/dfhack/issues/1775 diff --git a/docs/changelog.txt b/docs/changelog.txt new file mode 100644 index 0000000000..904fcc86fb --- /dev/null +++ b/docs/changelog.txt @@ -0,0 +1,2310 @@ +=== Scroll down for changes + +===[[[ +For information on how to edit/build the changelogs, see `docs/html/docs/dev/Documentation.html` or `docs/dev/Documentation.rst`. + +The text between the `syntax-reference` markers is included in `docs/dev/Documentation.rst`, so it must be valid RST. +It is kept in this file as a quick syntax reference. + +===syntax-reference-start + +The changelogs use a syntax similar to RST, with a few special sequences: + +- ``===`` indicates the start of a comment +- ``#`` indicates the start of a release name (do not include "DFHack") +- ``##`` indicates the start of a section name (which must be listed in ``docs/sphinx_extensions/dfhack/changelog.py``) +- ``-`` indicates the start of a changelog entry. **Note:** an entry currently must be only one line. +- ``:`` (followed by space) separates the name of a feature from a description of a change to that feature. + - Changes made to the same feature are grouped if they end up in the same section. +- ``:\`` (followed by space) avoids the above behavior +- ``- @`` (the space is optional) indicates the start of an entry that should only be displayed in ``NEWS-dev.rst``. + - Use this sparingly, e.g. for immediate fixes to one development build in another development build that + are not of interest to users of stable builds only. +- Three ``[`` characters indicate the start of a block (possibly a comment) that + spans multiple lines. Three ``]`` characters indicate the end of such a block. +- ``!`` immediately before a configured replacement (see ``docs/sphinx_extensions/dfhack/changelog.py``) stops that occurrence from being replaced. + +===syntax-reference-end + +Template for new versions: + +## New Tools + +## New Features + +## Fixes + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +]]] + +================================================================================ +======== IMPORTANT: rename this, and add a new "Future" section, BEFORE ======== +======== making a new DFHack release, even if the only changes made ======== +======== were in submodules with their own changelogs! ======== +================================================================================ + +# Future + +## New Tools + +## New Features + +## Fixes + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.16-r1.1 + +## New Tools + +## New Features + +## Fixes +- `stockpiles` will no longer incorrectly size the "rough gem" and "cut gem" vectors, which avoids a crash when viewing stockpile settings. This potentially affects anything that uses blueprints to create a stockpile, including `gui/quantum` + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.16-r1 + +## New Tools + +## New Features + +## Fixes +- ``TextArea`` widget corrected to use ``COLOR_BLACK`` instead of ``COLOR_RESET`` as default background color + +## Misc Improvements +- a safety check was added to ``Screen::doSetTile_char`` for out of bound pen color values + +## Documentation + +## API + +## Lua + +## Removed + +# 53.15-r3 + +## New Tools + +## New Features + +## Fixes +- `buildingplan`: restore planner UI elements: hollow constructions, only engraved slabs, only empty cages, weapon count + +## Misc Improvements +- `EventManager`: add safety check to potentially avoid a DFHack crash when DF's ``reports`` table is out of order + +## Documentation + +## API +- ``DFSDL``: added ``obtain_library_handle`` and ``obtain_image_library_handle`` so that a plugin can obtain DFHack's already-open handle to these libs instead of having to do it itself. +- ``Screen``: new functions ``paintMapPortTile`` and ``readMapPortTile`` to write and read world and region map tiles. +- ``Materials``: ``MaterialInfo`` constants ``NUM_BUILTIN``, ``GROUP_SIZE``, ``CREATURE_BASE``, ``FIGURE_BASE``, ``PLANT_BASE``, and ``END_BASE`` removed. New plugins should use appropriate members of the ``df::builtin_mats`` enum. + +## Lua +- Added ``Screen::paintMapPortTile`` as ``dfhack.screen.paintMapPortTile`` +- Added ``Screen::readMapPortTile`` as ``dfhack.screen.readMapPortTile`` +- Deprecated ``gui.materials.CREATURE_BASE`` and ``gui.materials.PLANT_BASE`` - scripts should instead use ``df.builtin_mats.CREATURE_1`` and ``df.builtin_mats.PLANT_1``, respectively. + +## Removed + +# 53.15-r2 + +## New Tools + +## New Features +- `buildingplan`: add a ``Pull`` button next to linked levers on a building's "Show linked buildings" tab so you can queue a high-priority pull-lever job (or cancel a queued one) without navigating to the lever + +## Fixes +- `autoclothing`: correct defect in validating material specification on command line +- `autolabor`: Fix running 1 tick less frequently than intended. +- `buildingplan`: fixed non-clickable pressure plates's triggers (issue #5736) +- `getplants`: added protective code to avoid misoperation when a plant has an invalid material (which should never happen, but...) + +## Misc Improvements +- `buildingplan`: added a slider on the weapontrap overlay +- `buildingplan`: added a small tooltip text about renaming favorites in the UI +- `buildingplan`: buildingplan can now generate work orders +- `orders`: exported orders now include a human-readable ``name`` field + +## Documentation + +## API +- Core: added ``getConfigPath()`` API for obtaining the path to user-specific configuration files +- ``widgets.RadioButton``: New button widget resembling those used in ``gui/control-panel`` + +## Lua +- Added ``dfhack.getConfigPath()`` API, proxying ``Core::getConfigPath`` + +## Removed + +# 53.15-r1 + +## New Tools + +## New Features + +## Fixes +- `autoclothing`: will no longer count gloves and pants as if they were helms +- `timestream`: do not skip ticks when a caravan is loading or unloading, and be more careful about skipping ticks when flows are active + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.14-r2 + +## New Tools + +## New Features + +## Fixes + +## Misc Improvements +- Core: attempts to delete a pool-allocated DF object will now throw an exception instead of corrupting the heap + +## Documentation + +## API + +## Lua + +## Removed +- `logcleaner`: Removed (cannot be safely implemented at this time) + +# 53.14-r1 + +## New Tools + +## New Features +- Compatibility with Dwarf Fortress 53.14 + +## Fixes + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.13-r2 + +## New Tools + +## New Features + +## Fixes +- ``Gui::makeAnnoucement``, ``Gui::showPopupAnnouncement`, and ``Gui::autoDFAnnouncement`` will no longer attempt to cull the DF announcement vector + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.13-r1 + +## New Tools + +## New Features + +## Fixes + +## Misc Improvements + +## Documentation +- updated documentation for ``autofarm`` for more clarity + +## API +- add flexible casting to ``enum_field`` to enable explicit casting to more types +- Handle units without current soul in ``Units::getFocusPenalty`` + +## Lua + +## Removed + +# 53.12-r1 + +## New Tools + +## New Features +- Compatibility with Dwarf Fortress 53.12 + +## Fixes +- Stockpile definitions in the default library will be correctly found and used (fixed missing path separator) + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.11-r3 + +## New Tools + +## New Features + +## Fixes +- Core: Windows console will always use UTF-8 regardless of system code page settings +- Steam launcher: Switch to injection strategy, allowing Dwarf Fortress and DFHack to be installed in disparate locations + +## Misc Improvements +- Make DFHack relocatable so that it doesn't depend on being fully co-installed with Dwarf Fortress + +## Documentation + +## API + +## Lua + +## Removed + +# 53.11-r2 + +## New Tools + +## New Features + +## Fixes +- `autoclothing`, `autoslab`, `tailor`: orders will no longer be created with a repetition frequency of ``NONE`` + +## Misc Improvements +- General: DFHack will unconditionally use UTF-8 for the console on Windows, now that DF forces the process effective system code page to 65001 during startup + +## Documentation + +## API + +## Lua + +## Removed + +# 53.11-r1 + +## New Tools + +## New Features + +## Fixes +- `sort`: correct misspelling of ``PERSEVERENCE``; fixes "hates combat" filter in squad selection screen + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.10-r2 + +## New Tools +- ``logcleaner``: New plugin for time-triggered clearing of combat, sparring, and hunting reports with configurable filtering and overlay UI. + +## New Features +- `orders`: added search overlay to find and navigate to matching manager orders with arrow indicators +- `sort`: added ``Uniformed`` filter to squad assignment screen to filter dwarves with mining, woodcutting, or hunting labors +- `sort`: Add death cause button to dead/missing tab in the creatures screen + +## Fixes + +## Misc Improvements +- Core: DFHack now validates vtable pointers in objects read from memory and will throw an exception instead of crashing when an invalid vtable pointer is encountered. This makes it easier to identify which DF data structure contains corrupted data when this manifests in the form of a bad vtable pointer, and shifts blame for such crashes from DFHack to DF. + +## Documentation + +## API +- Added ``Items::pickGrowthPrint``: given a plant material and a growth index, returns the print variant corresponding to the current in-game time. +- Added ``Items::useStandardMaterial``: given an item type, returns true if the item is made of a specific material and false if it has a race and caste instead. +- Added ``Maps::addItemSpatter``: add a spatter of the specified item + material + growth print to the indicated tile, returning whatever amount wouldn't fit in the tile. +- Added ``Maps::addMaterialSpatter``: add a spatter of the specified material + state to the indicated tile, returning whatever amount wouldn't fit in the tile. + +## Lua +- Added ``Maps::addItemSpatter`` as ``dfhack.maps.addItemSpatter``. +- Added ``Maps::addMaterialSpatter`` as ``dfhack.maps.addMaterialSpatter``. + +## Removed + +# 53.10-r1 + +## New Tools + +## New Features + +## Fixes +- `autochop`: the report will no longer throw a C++ exception when burrows are defined. +- `suspendmanager`: Fix the overlay appearing where it should not when following a unit + +## Misc Improvements + +## Documentation + +## API +- Added ``Burrows::getName``: obtains the name of a burrow, or the same placeholder name that DF would show if the burrow is unnamed. + +## Lua +- Added ``Burrows::getName`` as ``dfhack.burrows.getName``. + +## Removed + +# 53.09-r1 + +## New Tools + +## New Features +- `tweak`: ``drawbridge-tiles``: Make it so raised bridges render with different tiles in ASCII mode to make it more obvious that they ARE raised (and to indicate their direction) + +## Fixes +- ``Filesystem::as_string`` now always uses UTF-8 encoding rather than using the system locale encoding + +## Misc Improvements + +## Documentation + +## API +- ``dfhack.job.getManagerOrderName``: New function to get the display name of a manager order + +## Lua + +## Removed + +# 53.08-r1 + +## New Tools + +## New Features +- compatibility with DF 53.08 + +## Fixes + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.07-r1 + +## New Tools +- ``edgescroll``: Introduced plugin to pan the view automatically when the mouse reaches the screen border. +- `infinite-sky`: Re-enabled with compatibility with new siege map data. + +## New Features +- `sort`: Places search widget can search "Siege engines" subtab by name, loaded status, and operator status + +## Fixes +- `sort`: Using the squad unit selector will no longer cause Dwarf Fortress to crash on exit +- `sort`: Places search widget moved to account for DF's new "Siege engines" subtab + +## Misc Improvements +- `createitem`: created items can now be placed onto/into tables, nests, bookcases, display cases, and altars +- The ``fpause`` console command can now be used to force world generation to pause (as it did prior to version 50). +- `keybinding`: keybinds may now include the super key, and are no longer limited to particular keys ranges of keys, allowing any recognized by SDL. + +## Documentation + +## API +- ``Hotkey``: New module for hotkey functionality + +## Lua +- The ``Lua interactive interpreter`` banner now documents keywords such as ``unit`` and ``item`` which reference the currently-selected object in the DF UI. +- ``dfhack.hotkey.addKeybind``: Creates new keybindings +- ``dfhack.hotkey.removeKeybind``: Removes existing keybindings +- ``dfhack.hotkey.listActiveKeybinds``: Lists all keybinds for the current context +- ``dfhack.hotkey.listAllKeybinds``: Lists all keybinds for all contexts +- ``dfhack.hotkey.requestKeybindingInput``: Requests the next keybind-compatible input is saved +- ``dfhack.hotkey.getKeybindingInput``: Reads the input saved in response to a request. + +## Removed + +# 53.06-r1 + +## New Tools + +## New Features + +## Fixes + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed +- `infiniteSky`: Temporarily disabled due to incompatibility with changes made as part of DF's siege update + +# 53.05-r1 + +## New Tools + +## New Features +- compatibility with 53.05 + +## Fixes +- `sort`: Using the squad unit selector will no longer cause Dwarf Fortress to crash on exit + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.04-r1.1 + +## New Tools + +## New Features + +## Fixes +- fixed misalignment in ``widgets::unit_list`` + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 53.04-r1 + +## New Tools + +## New Features + +## Fixes +- `buildingplan`: Bolt throwers will no longer be constructed using populated bins. +- `RemoteFortressReader`: updated siege engine facing enums for new diagonal directions +- `suspendmanager`: treat reinforced walls as a blocking construction and buildable platform + +## Misc Improvements +- `autolabor`: support for new dying and siege-related labors +- `blueprint`: support for reinforced walls and bolt throwers + +## Documentation + +## API + +## Lua + +## Removed + +# 53.03-r1 + +## New Tools + +## New Features + +## Fixes + +## Misc Improvements +- Release builds for Linux are now compiled with gcc 11 + +## Documentation + +## API + +## Lua + +## Removed + +# 53.02-r2 + +## New Tools + +## New Features + +## Fixes +- `buildingplan`: Building costs for reinforced walls are now correct. +- `cleanconst`: do not attempt to clean Reinforced constructions + +## Misc Improvements +- `buildingplan`: Added support for bolt throwers and siege engine rotation. + +## Documentation + +## API + +## Lua + +## Removed + +# 53.02-r1 + +## New Tools + +## New Features + +## Fixes + +## Misc Improvements +- Core: added ``gps`` (``graphicst``) to the set of globals whose sizes must agree for DFHack to pass initialization checks + +## Documentation + +## API + +## Lua + +## Removed + +# 53.01-r1 + +## New Tools + +## New Features + +## Fixes + +## Misc Improvements +- `stockpiles`: add support for managing the dyed, undyed, and color filter settings. + +## Documentation + +## API + +## Lua + +## Removed + +# 52.05-r2 + +## New Tools + +## New Features + +## Fixes +- `script-manager`: the ``scripts_modactive`` and ``scripts_modinstalled`` folders of a script-enabled mod will be properly added to the script path search list + +## Misc Improvements + +## Documentation +- added a clarification link to DF's Lua API documentation to the DFHack Lua API documentation, as a way to reduce end-user confusion + +## API + +## Lua + +## Removed + +# 52.05-r1 + +## New Tools + +## New Features + +## Fixes +- improved file system handling: gracefully handle errors from operations, preventing crashes. +- `zone`: animal assignment dialog now tolerates corrupt animal-to-pasture links. + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 52.04-r1 + +## New Tools + +## New Features +- Compatibility with DF 52.04 + +## Fixes + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 52.03-r2 + +## New Tools + +## New Features +- `nestboxes`: allow limiting egg protection to nestboxes inside a designated burrow +- `tailor`: tailor now provides optional dye automation + +## Fixes +- ``Units::getReadableName`` will no longer append a comma to the names of histfigs with no profession +- `stockpiles`: fixed off-by-one error in exporting furniture stockpiles + +## Misc Improvements + +## Documentation + +## API +- ``Job``: new functions ``createLinked`` and ``assignToWorkshop`` +- ``Units``: new functions ``getFocusPenalty``, ``unbailableSocialActivity``, ``isJobAvailable`` + +## Lua +- New functions: ``dfhack.jobs.createLinked``, ``dfhack.jobs.assignToWorkshop``, ``dfhack.units.getFocusPenalty``, ``dfhack.units.unbailableSocialActivity``, and ``dfhack.units.isJobAvailable`` + +## Removed + +# 52.03-r1.1 + +## New Tools + +## New Features + +## Fixes +- job descriptions of mix dye job will display proper dye names + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 52.03-r1 + +## New Tools + +## New Features + +## Fixes +- `preserve-rooms` will no longer hang on startup in the presence of a cycle in the replacement relationship of noble positions + +## Misc Improvements + +## Documentation + +## API +- Adjusted the logic inside ``Military::removeFromSquad`` to more closely match the game's own behavior + +## Lua + +## Removed + +# 52.02-r2 + +## New Tools + +## New Features + +## Fixes +- Several fixes related to changes in file system handling in DF 52.01 +- `dig-now`: don't allow UNDIGGABLE stones to be excavated + +## Misc Improvements +- `autoclothing`: added a ``clear`` option to unset previously set orders + +## Documentation + +## API +- Added GUI focus strings for new_arena: ``/Loading`` and ``/Mods`` +- ``Filesystem::getBaseDir`` and ``Filesystem::getInstallDir`` added (and made available in Lua) +- Expanded the partial implementations of ``Military::addToSquad`` and ``Military::removeFromSquad`` + +## Lua +- Inserting values into STL containers containing nonprimitive types is now supported + +## Removed + +# 52.02-r1 + +## New Tools + +## New Features + +## Fixes +- Honor the "portable mode" preference setting for locating save folders. Fixes DFHack cosaves not working in most cases. + +## Misc Improvements + +## Documentation + +## API + +## Lua + +## Removed + +# 52.01-r1 + +## New Tools + +## New Features +- `tweak`: ``animaltrap-reuse``: make it so built animal traps automatically unload the vermin they catch into stockpiled animal traps, so that they can be automatically re-baited and reused + +## Fixes + +## Misc Improvements + +## Documentation + +## API + +## Lua +- ``widgets.Slider``: new mouse-controlled single-headed slider widget + +## Removed + +# 51.13-r1 + +## New Features + +- Compatibility with DF 51.13 + +# 51.12-r1.1 + +## New Features + +- Compatibility with Itch release of DF 51.12 + +# 51.12-r1 + +## Fixes +- `getplants`: will no longer crash when faced with plants with growths that do not drop seeds when processed +- `getplants`: use updated formula for calculating whether plant growths are ripe +- `getplants`: fix logic for determining whether plant growths have been picked +- `gui/teleport`: adapt to new behavior in DF 51.11 to avoid a crash when teleporting items into mid-air +- `script-manager`: fix lua scripts in mods not being reloaded properly upon entering a saved world on Windows +- `preserve-rooms`: don't warn when a room is assigned to a non-existent unit. this is now common behavior for DF when it keeps a room for an unloaded unit +- fixed an overly restrictive type constraint that resulted in some object types being glossed as a boolean when passed as an argument from C++ to Lua +- `plants`: will no longer generate a traceback when a filter is used +- `createitem`: multiple items should be properly created in stacks again + +## Misc Improvements +- All places where units are listed in DFHack tools now show the translated English name in addition to the native name. In particular, this makes units searchable by English name in `gui/sitemap`. +- `dig`: ASCII overlay now displays priority of digging designations +- `spectate`: added prefer nicknamed units +- `blueprint`: support for recording zones +- `blueprint`: support for recording stockpile properties like names and stockpile links; does not yet support recording detailed contents configuration +- `strangemood`: support added for specifying unit id instead of selected unit or random one. + +## API +- ``Random`` module: added ``SplitmixRNG`` class, implements the Splitmix64 RNG used by Dwarf Fortress for "simple" randomness +- ``Items::getDescription``: fixed display of quality levels, now displays ALL item designations (in correct order) and obeys vanilla SHOW_IMP_QUALITY setting +- ``cuboid::forCoord``, ``Maps::forCoord``: take additional parameter to control whether iteration goes in column major or row major order + +## Lua +- ``script-manager``: new ``get_active_mods()`` function for getting information on active mods +- ``script-manager``: new ``get_mod_info_metadata()`` function for getting information out of mod ``info.txt`` files + +## Removed +- removed historically unused ``Core::RegisterData``/``Core::GetData`` API and associated internal data structures + +# 51.11-r1.2 + +## Fixes +- `preserve-tombs`: will no longer crash when a tomb is assigned to a unit that does not exist + +# 51.11-r1.1 + +## Fixes +- `preserve-rooms`: will no longer crash when a civzone is assigned to a unit that does not exist +- `gui/design`: fix misaligned shape icons + +# 51.11-r1 + +## Fixes +- `spectate`: don't show a hover tooltip for hidden units (e.g. invisible snatchers) +- `stockpiles`: fix one-off error in item type when importing furniture stockpile settings +- `dig-now`: fix cases where boulders/rough gems of incorrect material were being generated when digging through walls +- `dig-now`: properly generate ice boulders when digging through ice walls +- `gui/teleport`: now properly handles teleporting units that are currently falling or being flung +- `unload`: fix recent regression where `unload` would immediately `reload` the target +- ``Buildings`` module: do not crash if a ``map_block`` unexpectedly contains an item that is not on the master item vector +- `suspendmanager`: fix walls being treated as potential suitable access if another wall is built underneath +- text widgets no longer lose their cursor when the Ctrl-a (select all) hotkey is pressed when there is no text to select + +## Misc Improvements +- `spectate`: show dwarves' activities (like prayer) + +## API +- ``Military`` module: added ``addToSquad`` function +- ``Units`` module: added ``get_cached_unit_by_global_id`` to emulate how DF handles unit vector index caching (used in civzones and in general references) +- ``Buildings`` module: add ``getOwner`` (using the ``Units::get_cached_unit_by_global_id`` mechanic) to reflect changes in 51.11 +- ``Units::teleport``: projectile information is now cleared for teleported units +- ``Buildings::setOwner``: updated for changes in 51.11 + +## Lua +- ``dfhack.military.addToSquad``: expose Military API function +- ``dfhack.buildings.getOwner``: make new Buildings API available to Lua + +# 51.10-r1 + +## Misc Improvements +- Compatibility with DF 51.10 + +# 51.09-r1 + +## New Features +- `gui/journal`: Ctrl-j hotkey to launch `gui/journal` now works in adventure mode! + +## Fixes +- Fix processing error in the overlay that displays unit preferences in the baron selection list + +## API +- ``Filesystem`` module: rewritten to use C++ standard library components, for better portability + +# 51.08-r1 + +## Misc Improvements +- Compatibility update for DF 51.08 + +# 51.07-r1 + +## New Features +- `spectate`: can now specify number of seconds (in real time) before switching to follow a new unit +- `spectate`: new "cinematic-action" mode that dynamically speeds up perspective switches based on intensity of conflict +- `spectate`: new global keybinding for toggling spectate mode: Ctrl-Shift-S +- `spectate`: new overlay panel that allows you to cycle through following next/previous units (regardless of whether spectate mode is enabled) +- `gui/sitemap`: is now the official "go to" tool. new global hotkey for fort and adventure mode: Ctrl-G + +## Fixes +- Windows console: fix possible hang if the console returns a too-small window width (for any reason) +- `createitem`: produced items will now end up at the look cursor position (if it is active) +- `spectate`: don't allow temporarily modified announcement settings to be written to disk when "auto-unpause" mode is enabled +- `changevein`: fix a crash that could occur when attempting to change a vein into itself +- `overlay`: reset draw context between rendering widgets so context changes can't propagate from widget to widget +- `suspendmanager`: in ASCII mode, building planning mode overlay now only displays when viewing the default map, reducing issues with showing through the UI + +## Misc Improvements +- `spectate`: player-set configuration is now stored globally instead of per-fort +- `autobutcher`: treat animals on restraints as unavailable for slaughter +- `stockpiles`: add property filters for brewable, millable, and processable (e.g. at a Farmer's workshop) organic materials +- `quickfort`: redesigned ``library/aquifer_tap.cav`` to improve the water fill rate + +## Documentation +- `stonesense-art-guide`: guide for making sprite art for Stonesense + +## API +- ``Military::removeFromSquad``: removes unit from any squad assignments +- ``Buildings::checkFreeTiles``: now takes a building instead of a pointer to the building extents +- ``Units::isUnitInBox``, ``Units::getUnitsInBox``: don't include inactive units +- ``Items::getItemBaseValue``: adjust to the reduced value of prepared meals (changed in DF 51.06) +- ``Items::getValue``: magical powers now correctly contribute to item value + +## Lua +- ``dfhack.units.setAutomaticProfessions``: sets unit labors according to current work detail settings +- ``dfhack.military.removeFromSquad``: Lua API for ``Military::removeFromSquad`` +- ``gui.dwarfmode``: adventure mode cursor now supported in ``getCursorPos``, ``setCursorPos``, and ``clearCursorPos`` funcitons +- ``dfhack.buildings.checkFreeTiles``: now takes a building pointer instead of an extents parameter +- ``overlay.isOverlayEnabled``: new API for querying whether a given overlay is enabled +- ``overlay``: widgets can now declare ``overlay_onenable`` and ``overlay_ondisable`` functions to hook enable/disable + +## Removed +- `orders`: MakeCheese job removed from library/basic orders set. Please use `autocheese` instead! + +# 51.06-r1 + +## Misc Improvements +- Compatibility with DF 51.06 + +# 51.05-r1 + +## Misc Improvements +- Compatibility with DF 51.05 + +# 51.04-r1.1 + +## Fixes +- `gui/launcher`: ensure commandline is fully visible when searching through history and switching from a very long command to a short command +- `gui/launcher`: flatten text when pasting multi-line text from the clipboard +- Ctrl-a hotkeys have been changed to something else (Ctrl-n) for tools that also have an editable text field, where Ctrl-a is interpreted as select all text + +## API +- ``Core::getUnpausedMs``: new API for getting unpaused ms since load in a fort-mode game + +# 51.04-r1 + +## Misc Improvements +- Compatibility with Steam release of DF 51.04 + +# 51.03-r1.1 + +## Misc Improvements +- Compatibility with Itch release of DF 51.03 + +# 51.03-r1 + +## Fixes +- `gui/gm-editor`: fix Enter key not being recognized for opening the selected object + +# 51.02-r1 + +## Misc Improvements +- DFHack edit field widgets, such as the commandline editor in `gui/launcher`, now support text selection and other advanced text editing features from `gui/journal` + +# 50.15-r2 + +## New Features +- `stockpiles`: add simple import/export dialogs to stockpile overlay panel +- `orders`: add transparent overlays to the manager orders screen that allow right clicks to cancel edit of quantities or condition details instead of exiting to the main screen + +## Fixes +- `preserve-rooms`: don't erroneously release reservations for units that have returned from their missions but have not yet entered the fort map +- `preserve-rooms`: handle case where unit records are culled by DF immediately after a unit leaves the map +- `preserve-tombs`: properly re-enable after loading a game that had the tool enabled +- `zone`: assign animal to cage/restraint dialog now allows you to unassign a pet from the cage or restraint if the pet is already somehow assigned (e.g. war dog was in cage and was subsequently assigned to a dwarf) +- `stockpiles`: don't set ``use_links_only`` flag to a random value when the flag is not set to anything in the settings that are being imported +- `strangemood`: ensure generated names for artifacts match what the game itself would generate + +## Misc Improvements +- `strangemood`: add ability to choose Stone Cutting and Stone Carving as the mood skill +- `suspendmanager`: add more specific messages for submerged job sites and those managed by `buildingplan` +- `dig-now`: handle digging in pool and river tiles + +## Documentation +- Added example code for creating plugin RPC endpoints that can be used to extend the DFHack API + +## API +- ``Units::isUnitInBox``, ``Units::getUnitsInBox``: add versions accepting pos arguments +- ``Units::getVisibleName``: when acting on a unit without an impersonated identity, returns the unit's name structure instead of the associated histfig's name structure +- ``Translation::generateName``: generates in-game names, mirroring DF's internal logic +- ``Persistence::getUnsavedSeconds``: returns the number of seconds since last save or load + +## Lua +- ``dfhack.units.isUnitInBox``, ``dfhack.units.getUnitsInBox``: add versions accepting pos arguments +- ``widgets.FilteredList``: search keys for list items can now be functions that return a string +- ``dfhack.translation.generateName``: Lua API for ``Translation::generateName`` +- ``dfhack.persistent.getUnsavedSeconds``: Lua API for ``Persistence::getUnsavedSeconds`` + +## Removed +- ``dfhack.TranslateName`` has been renamed to ``dfhack.translation.translateName`` + +## Internals +- Plugin command callbacks are now called with the core suspended by default so DF memory is always safe to access without extra steps +- Errors when unloading a plugin's DLL are now checked and reported + +# 50.15-r1.2 + +## Misc Improvements + +- Updated support for Itch + +# 50.15-r1.1 + +## Misc Improvements + +- Updated support for Classic (Itch not available for analysis yet) + +# 50.15-r1 + +## Fixes + +- `gui/prerelease-warning`: don't pop up during worldgen, only after a fort has been loaded + +# 50.14-r2 + +## New Tools +- `infinite-sky`: (reinstated, renamed from ``infiniteSky``) automatically create new z-levels of sky to build in +- `forceequip`: (reinstated) forcibly move items into a unit's inventory + +## New Features +- `tweak`: ``realistic-melting``: change melting return for inorganic armor parts, shields, weapons, trap components and tools to stop smelters from creating metal, bring melt return for adamantine in line with other metals to ~95% of forging cost. wear reduces melt return by 10% per level + +## Fixes +- Fix mouse clicks bleeding through resizable DFHack windows when clicking in the space between the frame and the window content +- `autobutcher`: don't run a scanning and marking cycle on the first tick of a fortress to allow for all custom configuration to be set first +- `nestboxes`: don't consider eggs to be infertile just because the mother has left the nest; eggs can still hatch in this situation +- `timestream`: adjust the incubation counter on fertile eggs so they hatch at the expected time +- `timestream`: adjust the timeout on traps so they can be re-triggered at normal rates +- `logistics`: don't ignore rotten items when applying stockpile logistics operations (e.g. autodump, autoclaim, etc.) + +## Misc Improvements +- DFHack now verifies that critical DF data structures have known sizes and refuses to start if there is a mismatch +- DFHack text edit fields now delete the character at the cursor when you hit the Delete key +- DFHack text edit fields now move the cursor by one word left or right with Ctrl-Left and Ctrl-Right +- DFHack text edit fields now move the cursor to the beginning or end of the line with Home and End +- Quickfort blueprint library: ``aquifer_tap`` blueprint walkthough rewritten for clarity +- Quickfort blueprint library: ``aquifer_tap`` blueprint now designated at priority 3 and marks the stairway tile below the tap in "blueprint" mode to prevent drips while the drainage pipe is being prepared +- `preserve-rooms`: automatically release room reservations for captured squad members. we were kidding ourselves with our optimistic kept reservations. they're unlikely to come back : (( +- `buildingplan`: add value info to item selection dialog (effectively ungrouping items with different values) and add sorting by value +- `timestream`: improve FPS by a further 10% +- `fix/occupancy`: additionally handle the case where tile building occupancy needs to be set instead of cleared +- `orders`: ``orders sort`` now moves orders that are tied to a specific workshop to the top of the list in the global manager orders screen +- `gui/pathable`: make wagon path to depot representation more robust + +## Documentation +- Dreamfort: add link to Dreamfort tutorial youtube series: https://www.youtube.com/playlist?list=PLzXx9JcB9oXxmrtkO1y8ZXzBCFEZrKxve +- The error message that comes up if there is a version mismatch between DF and DFHack now informs you which DF versions are supported by the installed version of DFHack + +## API +- ``DFHack::Units``: new function ``setPathGoal`` +- ``Units::setAutomaticProfessions``: bay12-provided entry point to assign labors based on work details + +## Lua +- ``dfhack.units``: new function ``setPathGoal`` +- ``widgets.TabBar``: updated to allow for horizontal scrolling of tabs when there are too many to fit in the available space + +## Removed +- UI focus strings for squad panel flows combined into a single tree: ``dwarfmode/SquadEquipment`` -> ``dwarfmode/Squads/Equipment``, ``dwarfmode/SquadSchedule`` -> ``dwarfmode/Squads/Schedule`` +- `faststart`: removed since the vanilla startup sequence is now sufficiently fast + +# 50.14-r1 + +## Fixes +- `preserve-rooms`: don't reserve a room for citizens that you expel from the fort +- `autobutcher`: fix regression in ordering of butcherable animals + +# 50.13-r5 + +## New Tools +- `preserve-rooms`: manage room assignments for off-map units and noble roles. reserves rooms owned by traveling units and reinstates their ownership when they return to the site. also allows you to assign rooms to noble/administrator roles, and the rooms will be automatically assigned whenever the holder of the role changes + +## Fixes +- prevent hang when buildings in zones are destroyed in the case where the buildings were not added to the zone in the same order that they were created (uncommon) +- `buildingplan`: improved performance in forts with large numbers of items +- System clipboard: when pasting single lines from the system clipboard, replace newlines with spaces so they don't show up as strange CP437 glyphs in-game +- `exterminate`: don't kill friendly undead (unless ``--include-friendly`` is passed) when specifying ``undead`` as the target +- `gui/settings-manager`: work details overlay no longer disappears when you click on a unit in the unit list +- `buildingplan`: fixed processing errors when using quick material filter slot '0' +- DFHack screens that allow keyboard cursor and camera movement while focused now also allow diagonal and Z-change keyboard cursor keys +- `strangemood`: manually-triggered Macabre moods will now correctly request up to 3 bones/remains for the primary component instead of only 1 +- `regrass`: no longer add all compatible grass types when using ``--force`` without ``--new`` +- `regrass`: ``--mud`` now converts muddy slade to grass, consistent with normal DF behavior +- `gui/pathable`: fix hang when showing trade depot wagon access and a trade depot is submerged under water or magma +- `gui/pathable`: fix representation of wagon paths over stairs and through doors +- DFHack state for a site is now properly saved when retiring a fort +- `gui/teleport`: fix issue when teleporting units that are not prone, resulting in later issues with phantom "cannot build here: unit blocking tile" messages + +## Misc Improvements +- `sort`: can now search for stockpiles on the Places>Stockpile tab by name, number, or enabled item categories +- `gui/family-affairs`: you can start this tool by the name ``gui/pregnancy`` to start directly on the "Pregnancies" tab +- `buildingplan`: only consider building materials that can be accessed by at least one citizen/resident +- Dreamfort: integrate with `preserve-rooms` to assign relevant rooms to nobles/adimistrators +- Dreamfort: smooth tiles under statues and other large furniture that you can't easily smooth later + +## Documentation +- add documentation for ``dfhack.items.findType(string)`` and ``dfhack.items.findSubtype(string)`` +- `modding-guide`: added examples for reading and writing various types of persistent storage +- `modding-guide`: updated all code snippets for greater clarity + +## API +- ``Units``: new ``isWildlife`` and ``isAgitated`` property checks +- ``Items::createItem``: removed ``growth_print`` parameter; now determined automatically +- ``DFHack::cuboid``: ``cuboid::clampMap`` now returns the cuboid itself (instead of boolean) to allow method chaining; call ``cuboid::isValid`` to determine success + +## Lua +- ``dfhack.units``: ``isWildlife`` and ``isAgitated`` property checks +- ``dfhack.units.isDanger``: no longer unconditionally returns true for intelligent undead +- Overlay widgets can now assume their ``active`` and ``visible`` functions will only execute in a context that matches their ``viewscreens`` associations +- ``gui.simulateInput``: do not generate spurious keycode from ``_STRING`` key inputs +- ``dfhack.items.createItem``: removed ``growth_print`` parameter to match C++ API + +## Removed +- ``quickfortress.csv``: remove old sample blueprints for "The Quick Fortress", which were unmaintained and non-functional in DF v50+. Online blueprints are available at https://docs.google.com/spreadsheets/d/1WuLYZBM6S2nt-XsPS30kpDnngpOQCuIdlw4zjrcITdY if anyone is interested in giving these blueprints some love + +# 50.13-r4 + +## New Features +- `gui/journal`: new hotkey, accessible from anywhere in fort mode: Ctrl-j + +## Fixes +- `changelayer`: fix incorrect lookup of geological region in multi-region embarks +- Copy/Paste: Fix handling of multi-line text when interacting with the system clipboard on Windows +- `zone`: fix alignment of animal actions overlay panel (the one where you can click to geld/train/etc.) when the animal has a custom portrait (like named dragons) +- `autodump`: cancel any jobs that point to dumped items +- `add-spatter`: fix a crash related to unloading a savegame with add-spatter reactions, then loading a second savegame with add-spatter reactions +- `plant`: properly detect trees in a specified cuboid that only have branches/leaves in the cuboid area + +## Misc Improvements +- performance improvements for DFHack tools and infrastructure +- `gui/pathable`: give edge tiles where wagons can enter the map a special highlight to make them more identifiable. this is especially useful when the game decides that only a portion of the map edge is usable by wagons. +- `autodump`: allow dumping items into mid-air, converting them into projectiles like `gui/autodump` does + +## Documentation +- improved docs for ``dfhack.units`` module functions + +## API +- ``Units``: add overloads that take historical figures for ``getReadableName``, ``getVisibleName``, and ``getProfessionName`` +- ``Units::isUnitInBox``, ``getUnitsInBox``: add versions that take a cuboid range, add filter fn parameter for ``getUnitsInBox`` +- ``Units::getProfession``: account for units with fake identities +- ``Units::getCasteRaw``: get a caste_raw from a unit or race and caste +- ``cuboid``: construct from ``df::map_block*``, ``forBlock`` iterator to access map blocks in cuboid +- ``cuboid``: ``clamp(cuboid other)``, ``clampNew(cuboid other)`` for cuboid intersection. ``clampNew`` returns new cuboid instead of modifying. +- ``Items``: no longer need to pass MapCache parameter to ``moveToGround``, ``moveToContainer``, ``moveToBuilding``, ``moveToInventory``, ``makeProjectile``, or ``remove`` +- ``Units::isVisible``: account for units in cages +- ``Units::getReadableName``: correct display of ghost+curse names w/r/t each other and unit prof, use ``curse.name`` instead of iterating syndrome name effects +- ``setAreaAquifer``, ``removeAreaAquifer``: add overloads that take cuboid range specifiers +- ``Units::isNaked``: now only checks equipped items (including rings, for now). Setting bool ``no_items`` to true checks empty inventory like before. +- ``Units::isUndead``: bool ``include_vamps`` renamed to ``hiding_curse``. Fn now checks that instead of bloodsucker syndrome. +- ``Units::isDanger``: added bool ``hiding_curse``, passed to ``isUndead`` to avoid spoilers +- ``Units::getRaceChildName``, ``getRaceChildNameById``, ``getRaceBabyName``, ``getRaceBabyNameById``: bool ``plural`` to get plural form +- ``Units::getProfessionName``: bool ``land_title`` to append "of Sitename" where applicable, use Prisoner/Slave and noble spouse titles (controlled by ``ignore_noble``) + +## Lua +- ``gui.ZScreen``: new ``defocused`` property for starting screens without keyboard focus +- ``dfhack.units``: allow historical figures to be passed instead of units for ``getReadableName``, ``getVisibleName``, and ``getProfessionName`` +- ``dfhack.items.moveToInventory``: make ``use_mode`` and ``body_part`` args optional +- ``dfhack.units``: add ``getRaceReadableName``, ``getRaceReadableNameById``, ``getRaceNamePluralById`` + +## Removed +- The ``PRELOAD_LIB`` environment variable has been renamed to ``DF_PRELOAD`` to match the naming scheme of other environment variables used by the ``dfhack`` startup script. If you are preloading libraries (e.g. for performance testing) please define ``DF_PRELOAD`` instead of ``PRELOAD_LIB`` or ``LD_PRELOAD`` +- ``cuboid::clamp(bool block)``: renamed to ``cuboid::clampMap(bool block)``, name taken by ``cuboid::clamp(cuboid other)`` +- ``Units::MAX_COLORS``, ``Units::findIndexById``, ``Units::getNumUnits``, ``Units::getUnit``: replaced by ``DFHack::COLOR_MAX`` and the generated type-specific ``get_vector`` functions +- ``Units::getPhysicalDescription``: function requires DF call point that is no longer available. alternative is to navigate the unit info sheet and extract the description from the UI (see `markdown`) + +# 50.13-r3 + +## New Tools +- `plant`: (reinstated) tool for creating/growing/removing plants + +## New Features +- `tweak`: ``named-codices``: display book titles instead of a material description in the stocks/trade screens +- `logistics`: automatically forbid or claim items brought to a stockpile +- `plant`: can now ``remove`` shrubs and saplings; ``list`` all valid shrub/sapling raw IDs; ``grow`` can make mature trees older; many new command options +- Locale-sensitive number formatting: select your preferred format in `gui/control-panel`. prices and other large numbers in DFHack UIs can be displayed with commas (English formatting), the number formatting used by your system locale, in SI units (e.g. ``12.3k``), or even in scientific notation + +## Fixes +- ``Gui::makeAnnouncement``, ``Gui::autoDFAnnouncement``: fix case where a new announcement is created instead of adding to the count of an existing announcement if the existing announcement was the first one in the reports vector +- `regrass`: don't remove mud on regrass, consistent with vanilla behavior +- `seedwatch`: display a limit of ``-`` instead of ``0`` for a seed that is present in inventory but not being watched +- `tiletypes`: make aquifers functional when adding the ``aquifer`` property and there are no existing aquifer tiles in the same map block +- `seedwatch`: do not include unplantable tree seeds in status report +- ``Buildings::containsTile``: fix result for buildings that are solid and have no extent structures +- Mortal mode: prevent keybindings that run armok tools from being recognized when in mortal mode +- `dig`: don't leave phantom dig designations behind when autodigging warm/damp designated tiles +- `buildingplan`: properly identify appropriate construction items for modded buildings built from thread +- `overlay`: overlay positions are now adjusted according to the configured max interface width percentage in the DF settings +- `zone`: animal assignment overlay button moved to not conflict with vanilla aquarium/terrarium button on glass cages +- `zone`: allow friendly creatures to be released from cages by assigning them to a pasture zone and then unassigning them +- `autobutcher`: fix inverted ranking of which animals to butcher first + +## Misc Improvements +- `blueprint`: capture track carving designations in addition to already-carved tracks +- `changevein`: follow veins into adjacent map blocks so you can run the command once instead of once per map block that the vein crosses +- `regrass`: now accepts numerical IDs for grass raws; ``regrass --list`` replaces ``regrass --plant ""`` +- `tiletypes`: performance improvements when affecting tiles over a large area +- `tiletypes`: support for creating heavy aquifers +- `tiletypes`: new ``autocorrect`` property for autocorrecting adjacent tiles when making changes (e.g. adding ramp tops when you add a ramp) +- Dreamfort: add a full complement of beds and chests to both barracks +- Dreamfort: redesign guildhall/temple/library level for better accessibility +- Dreamfort: walkthrough documentation refresh +- Dreamfort: add milking/shearing station in surface grazing pasture +- Dreamfort: integrate building prioritization into the blueprints and remove `prioritize` checklist steps +- Dreamfort: add plumbing template for filling cisterns with running water +- `buildingplan`: add option to ignore items from a specified burrow +- `autobutcher`: do not butcher pregnant (or brooding) females +- `quickfort`: support buildable instruments +- `orders`: you can now delete your exported orders from the import dialog +- `nestboxes`: increase the scanning frequency for fertile eggs to reduce the chance that they get snarfed by eager dwarves +- `autonestbox`: wait until juveniles become adults before they are assigned to nestboxes +- `suspendmanager`: add option to ``unsuspend`` that unsuspends all jobs, regardless of potential issues (like blocking other construction jobs) +- `gui/create-item`: allow right click to cancel out of material dialog submenus + +## Documentation +- `installing`: add instructions for how to use Steam DFHack with non-Steam DF (e.g. to benefit from DFHack auto-updates and cloud backups) +- `modding-guide`: add a section on persistent storage, both for global settings and world-specific settings +- Developer's primer for DFHack's type identity system + +## API +- Focus strings have moved for stockpile states: ``dwarfmode/CustomStockpile`` is now ``dwarfmode/Stockpile/Some/Customize`` and similar for ``dwarfmode/StockpileTools`` and ``dwarfmode/StockpileLink`` +- ``Buildings::getName``: get a building's name +- ``Maps::isTileAquifer``, ``Maps::isTileHeavyAquifer``, ``Maps::setTileAquifer``, ``Maps::removeTileAquifer``, ``Maps::setAreaAquifer``, ``Maps::removeAreaAquifer``: new aquifer detection and modification API +- ``Units::create``, ``Units::makeown``: new APIs to use bay12-provided entry points for low-level operations +- ``format_number``: format numbers according to the configured player formatting preference +- ``Items::remove``: now cancels related jobs and marks the item as hidden and forbidden until it can be garbage collected +- ``Job::addGeneralRef``: new easy API for creating general references and adding them to a Job +- ``Job::addWorker``: new API function for assigning a job to unit + +## Lua +- ``dfhack.gui.getSelectedJob``: can now return the job with a destination under the keyboard cursor (e.g. digging/carving/engraving jobs) +- ``widgets.makeButtonLabelText``: create text and graphical buttons from character/color/tile maps and/or dynamically loaded tilesets +- ``widgets.DimensionsTooltip``: reusable selected dimensions tooltip that follows the mouse cursor around +- ``widgets.ButtonGroup``: subclass of CycleHotkeyLabel that additionally displays clickable graphical buttons +- ``widgets.CycleHotkeyLabel``: when the widget has both forward and backward hotkeys defined, support moving backwards by clicking on the appropriate hotkey hint +- ``safe_index``: will now return nil when attempting to index into a non-indexable object +- ``script-manager``: add ``getModSourcePath`` and ``getModStatePath`` so modders can get the directory path to their own files +- ``widgets.FilteredList``: don't restrict the player from inputting multiple successive space characters +- ``dfhack.maps.isTileAquifer``, ``dfhack.maps.isTileHeavyAquifer``, ``dfhack.maps.setTileAquifer``, ``dfhack.maps.removeTileAquifer``: access to new aquifer API +- ``plugins.tiletypes.tiletypes_setTile``: can now accept a table for access to previously unavailable options +- ``dialogs.showYesNoPrompt``: extend options so the standard dialog can be used for `gui/confirm`-style confirmation prompts +- ``dfhack.units.create``, ``dfhack.units.makeown``: Lua access to new module API +- ``dfhack.formatInt``, ``dfhack.formatFloat``: formats numbers according to the player preferences for number formatting set in `gui/control-panel` +- ``gui.get_interface_rect``, ``gui.get_interface_frame``: convenience functions for working with scaled interfaces +- ``overlay``: new attributes: ``fullscreen`` and ``full_interface`` for overlays that need access to the entire screen or the scaled interface area, respectively +- ``string:wrap``: now preserves inter-word spacing and can return the wrapped lines as a table of strings instead of a single multi-line string +- ``dfhack.internal.getClipboardTextCp437Multiline``: for retrieving multiline text from the system clipboard + +## Removed +- `plants`: renamed to `plant` +- ``gui.FramedScreen``: this class is now deprecated; please use ``gui.ZScreen`` and ``widgets.Window`` instead +- ``dfhack.HIDE_CONSOLE_ON_STARTUP`` and ``dfhack.HIDE_ARMOK_TOOLS`` are no longer directly accessible. Please use `control-panel` or `gui/control-panel` to interact with those settings. + +# 50.13-r2.1 + +## Fixes +- `suspendmanager`: stop suspending single tile stair constructions + +# 50.13-r2 + +## New Tools +- Updated for adventure mode: `reveal` + +## New Features +- `buildingplan`: quick material filter favorites on main planner panel +- DFHack and the Dwarf Fortress translation project can now both be run at the same time + +## Fixes +- `zone`: fix display of distance from cage/pit for small pets in assignment dialog +- `blueprint`: correctly define stockpile boundaries in recorded stockpile ("place") blueprints when there are adjacent non-rectangular stockpiles of identical types +- `dig`: refresh count of tiles that will be modified by "mark all designated tiles on this z-level for warm/damp dig" when the z-level changes +- `dig`: don't affect already-revealed tiles when marking z-level for warm/damp dig +- `zone`: refresh values in distance column when switching selected pastures when the assign animals dialog is open +- `logistics`: include semi-wild pets when autoretrain is enabled +- `suspendmanager`: fully suspend unbuildable dead ends (e.g. building second level of a wall when the wall top is only accessible via ramp, causing the planned wall to be pathable but not buildable) +- `prospect`: don't use scientific notation for representing large numbers + +## Misc Improvements +- `caravan`: display who is in the cages you are selecting for trade and whether they are hostile +- `regrass`: can now add grass to stairs, ramps, ashes, buildings, muddy stone, shrubs, and trees +- `regrass`: can now restrict area of effect to specified tile, block, cuboid, or z-levels +- `regrass`: can now add grass in map blocks where there hasn't been any +- `regrass`: can now choose specific grass type +- `dig`: warm/damp/aquifer status will now be shown in mining mode for tiles that your dwarves can see from the level below +- `dig`: warm/damp/aquifer status will now be shown when in smoothing/engraving modes +- `stockpiles`: support import and export "desired items" configuration for route stops +- New commandline options for controlling the Cloud Save coprocess when launching from Steam. See the `dfhack-core` documentation for details. +- `markdown`: new keybinding for triggering text export: Ctrl-t (when unit or item is selected) +- `flashstep`: new keybinding for teleporting adventurer to the mouse cursor: Ctrl-t (when adventure map is in the default state and mortal mode is disabled in DFHack preferences) +- Dreamfort: move wells on services level so brawling drunken tavern patrons are less likely to fall in +- `unretire-anyone`: new keybinding for adding a historical figure to the adventurer selection list in the adventure mode setup screen: Ctrl-a + +## Documentation +- Quickfort Blueprint Library: add demo videos for pump stack and light aquifer tap blueprints +- Update docs for dependency requirements and compilation procedures + +## API +- ``dfhack.items.getReadableDescription()``: easy API for getting a human-readable item description with useful annotations and information (like tattered markers or who is in a cage) +- ``Items::createItem``: now returns a list of item pointers rather than a single ID, moved creator parameter to beginning, added growth_print and no_floor parameters at end +- ``World::getAdventurer``: returns current adventurer unit +- ``World::ReadPauseState``: now returns true when the game is effectively paused due to a large panel obscuring the map. this aligns the return value with the visual state of the pause button when in fort mode. + +## Lua +- ``dfhack.internal.setClipboardTextCp437Multiline``: for copying multiline text to the system clipboard +- ``dfhack.world.getAdventurer``: returns current adventurer unit +- ``dfhack.items.createItem``: return value and parameters have changed as per C++ API + +# 50.13-r1.1 + +## Documentation +- Update docs on release procedures and symbol generation + +# 50.13-r1 + +## Fixes +- Fixed misidentification of visitors from your own civ as residents; affects all tools that iterate through citizens/residents +- `cursecheck`: act on selected unit only if a unit is selected +- Fixed incorrect DFHack background window texture when DF is started in ascii mode and subsequently switched to graphics mode + +## Misc Improvements +- `suspendmanager`: Account for walls planned on the z-layer below when determining accessibility to a job + +## Documentation +- `autoclothing`: add section comparing ``autoclothing`` and `tailor` to guide players choosing which to enable + +# 50.12-r3 + +## New Tools +- `aquifer`: commandline tool for creating, draining, and modifying aquifers + +## New Features +- `buildingplan`: add overlays for unlinking and freeing mechanisms from buildings +- `dig`: designate tiles for damp or warm dig, which allows you to dig through damp or warm tiles without designations being canceled +- `dig`: damp and warm tile icons now remain visible when included in the designation selection box (graphics mode) +- `dig`: aquifer tiles are now visually distinct from "just damp" tiles (graphics and ascii modes) +- `dig`: light aquifer tiles are now visually distinct from heavy aquifer tiles (graphics and ascii modes) +- `dig`: autodig designations that are marked for damp/warm dig propagate the damp/warm tag when expanding to newly exposed tiles +- `blueprint`: designations and active dig jobs are now captured in generated blueprints +- `blueprint`: warm/damp dig markers are captured in generated blueprints + +## Fixes +- fix behavior of Linux Steam launcher on systems that don't support the inotify API +- fix rendering of resize "notch" in lower right corner of resizable windows in ascii mode +- `quickfort`: stockpiles can now be placed even if there is water covering the tile, as per vanilla behavior +- `suspendmanager`: prevent cancellation spam when an item is preventing a building from being completed +- `stonesense`: fix a crash with buildings made of unusual materials (such as campsite tents made out of organic "walls") + +## Misc Improvements +- `tailor`: allow turning off automatic confiscation of tattered clothing +- aquifer_tap blueprint: now designates in damp dig mode for uninterrupted digging in a light aquifer +- pump_stack blueprint: now designates in warm and damp dig mode for uninterrupted digging through warm and damp tiles +- `keybinding`: you can now assign keybindings to mouse buttons (if your mouse has more than the three buttons already used by DF) + +## Documentation +- Lua API: documented existing ``enum:next_item(index)`` function + +## API +- ``Units::citizensRange``: c++-20 std::range filter for citizen units +- ``Units::forCitizens``: iterator callback function for citizen units +- ``Units::paintTile``, ``Units::readTile``: now takes an optional field specification for reading and writing to specific map compositing layers +- ``Buildings::checkFreeTiles``: now takes a ``allow_flow`` parameter to control whether water- or magma-filled tiles are valid + +## Lua +- ``dfhack.gui.matchFocusString``: focus string matching is now case sensitive (for performance reasons) + +# 50.12-r2.1 + +## Fixes +- `orders`: don't intercept keyboard input for setting skill or labor restrictions on workshop workers tab when the player is setting the building nickname + +# 50.12-r2 + +## New Features +- `stocks`: add button/hotkey for removing empty categories from the stocks list +- `sort`: updated and reinstated military status/squad membership/burrow membership filter for work animal assignment screen +- `logistics`: ``autoretrain`` will automatically assign trainers to your partially-trained (but not yet domesticated) livestock. this prevents children of partially-trained parents from reverting to wild if you don't notice they were born +- `orders`: add overlay for configuring labor and skill level restrictions for workshops + +## Fixes +- `autochop`: fix underestimation of log yield for cavern mushrooms +- `gui/notify`: prevent notification overlay from showing up in arena mode +- `logistics`: don't melt/trade/dump empty containers that happen to be sitting on the stockpile unless the stockpile accepts those item types +- `gui/launcher`: fix detection on Shift-Enter for running commands and autoclosing the launcher +- `logistics`: don't send autotrade items to forbidden depots +- `autoclothing`: don't produce clothes for dead units +- `caravan`: fix trade price calculations when the same item was requested for both import and export + +## Misc Improvements +- `autobutcher`: prefer butchering partially trained animals and save fully domesticated animals to assist in wildlife domestication programs +- `autodump`: can now teleport items loosely stored in buildings (clutter) +- When launched from the Steam client on Linux, both Dwarf Fortress and DFHack will be shown as "Running". This ensures that DF has proper accounting for Linux player usage. +- `suspendmanager`: improve performance when there are many active jobs +- `clean`: protect farm plots when cleaning mud +- `tweak`: add ``quiet`` option for silent enablement and disablement of tweaks +- `gui/teleport`: add global Ctrl-Shift-T keybinding (only available when DFHack mortal mode is disabled) +- Dreamfort: the four Craftsdwarf's workshops on the industry level are now specialized for Stonecrafting, Woodcrafting, Bone Carving, and miscellaneous tasks, respectively +- `dwarfvet`: automatically unassign animals from pastures when they need treatment so they can make their way to the hospital. reassign them to their original pasture when treatment is complete. +- `dwarfvet`: ignore animals assigned to cages or restraints +- Many tools that previously only worked for citizens or only for dwarves now work for all citizens and residents, e.g. `fastdwarf`, `rejuvenate`, etc. +- `buildingplan`: remember player preference for whether unavailable materials should be hidden in the filter selection dialog +- `buildingplan`: sort by available quantity by default int he filter selection dialog +- Dreamfort: update embark profile recommendations and example embark profile + +## Documentation +- `overlay-dev-guide`: updated examples and troubleshooting steps +- `introduction`: refresh getting started content +- `quickstart`: refresh quickstart guide + +## API +- ``Units::isForgottenBeast``: property check for forgotten beasts +- ``Units::isGreatDanger``: now includes forgotten beasts +- ``Units::isResident``: property check for residents (as opposed to citizens) +- ``Units::getCitizens``: now includes residents by default + +## Lua +- ``widgets.Label``: ``*pen`` attributes can now either be a pen or a function that dynamically returns a pen +- `helpdb`: ``search_entries`` now returns a match if *all* filters in the ``include`` list are matched. previous behavior was to match if *any* ``include`` filter matched. +- ``matinfo.decode``: now directly handles plant objects +- ``dfhack.units.isForgottenBeast``: make new units method available to Lua +- ``dfhack.units.getCitizens``: now includes residents by default + +# 50.12-r1.1 + +## Fixes +- `sort`: fix crash when assigning work animals to units + +## Removed +- offline HTML rendered docs are no longer distributed with DFHack since they are randomly triggering Windows Defender antivirus heuristics. If you want to download DFHack docs for offline browsing, you can still get them from the Downloads link at https://dfhack.org/docs + +# 50.12-r1 + +## Misc Improvements +- `sort`: squad assignment overlay rewritten for compatibility with new vanilla data structures and screen layouts + +## Fixes +- `gui/design`: no longer comes up when Ctrl-D is pressed but other DFHack windows have focus + +## API + +- ``Gui::getWidget``: retrieve a vanilla DF widget by name or index + +## Lua + +- ``dfhack.gui.getWidget``: retrieve a vanilla DF widget by hierarchy path, with each step specified by a widget name or index +- ``dfhack.gui.getWidgetChildren``: retrieve a list of child widgets for a given widget container + +## Removed +- `burrow`: removed overlay 3D box select since it is now provided by the vanilla UI +- `sort`: removed Search widgets for screens that now have vanilla search + +# 50.11-r7 + +## New Tools +- `tweak`: (reinstated) a collection of small bugfixes and gameplay tweaks +- `pet-uncapper`: (reinstated, renamed from ``petcapRemover``) allow pets to breed beyond the default population cap of 50 + +## New Features +- `cleanowned`: Add a "nodump" option to allow for confiscating items without dumping +- `tweak`: Add "flask-contents", makes flasks/vials/waterskins be named according to their contents + +## Fixes +- `dig`: overlay that shows damp designations in ASCII mode now properly highlights tiles that are damp because of an aquifer in the layer above +- `dig-now`: fix digging stairs in the surface sometimes creating underworld gates. +- ``Units::getVisibleName``: don't reveal the true identities of units that are impersonating other historical figures +- ``Gui::revealInDwarfmodeMap``: properly center the zoom even when the target tile is near the edge of the map +- `warn-stranded`: don't complain about units that aren't on the map (e.g. soldiers out on raids) +- `autoclothing`: Fix enabled behavior +- ``Gui::makeAnnouncement``, ``Gui::autoDFAnnouncement``: don't display popup for all announcement types +- ``gui.View:getMouseFramePos``: function now detects the correct coordinates even when the widget is nested within other frames +- `strangemood`: correctly recognize Stonecutter and Stone Carver as moodable skills, move the Mason's boosted mood chance to the Stone Carver, and select Fell/Macabre based on long-term stress + +## Misc Improvements +- `autonestbox`: assign egg layers to the nestbox they have chosen if they have already chosen a nestbox +- `regrass`: also regrow depleted cavern moss +- `probe`: act on the selected building/unit instead of requiring placement of the keyboard cursor for ``bprobe`` and ``cprobe`` +- `buildingplan`: use closest matching item rather than newest matching item +- `zone`: animal assignment dialog now shows distance to pasture/cage and allows sorting by distance +- `zone`: animal assignment dialog shows number of creatures assigned to this pasture/cage/etc. + +## API +- Gui module Announcement functions now use DF's new announcement alert system +- ``Gui::addCombatReport``, ``Gui::addCombatReportAuto``: add versions that take ``report *`` instead of report vector index +- ``Gui::MTB_clean``, ``Gui::MTB_parse``, ``Gui::MTB_set_width``: new functions for manipulating ``markup_text_boxst`` +- ``toupper_cp437(char)``, ``tolower_cp437(char)``: new ``MiscUtils`` functions, return a char with case changed, respecting CP437 +- ``toUpper``, ``toLower``: ``MiscUtils`` functions renamed to ``toUpper_cp437`` and ``toLower_cp437``, CP437 compliant +- Gui focus strings will now include ``dwarfmode/Default`` if the only other panel open is the Squads panel +- ``Gui::revealInDwarfmodeMap``: unfollow any currently followed units/items so the viewport doesn't just jump back to where it was + +## Lua +- Overlay framework now respects ``active`` and ``visible`` widget attributes +- ``dfhack.gui`` announcement functions use default arguments when omitted +- ``dfhack.units.getCitizens`` now only returns units that are on the map +- ``dfhack.upperCp437(string)``, ``dfhack.lowerCp437(string)``: new functions, return string with all chars changed, respecting CP437 code page + +# 50.11-r6 + +## New Features +- `zone`: Add overlay for toggling butchering/gelding/adoption/taming options in animal "Overview" tabs + +## Fixes +- `dig-now`: remove diagonal ramps rendered unusable by digging +- `dig-now`: fix error propagating "light" and "outside" properties to newly exposed tiles when piercing the surface +- `sort`: fix potential crash when switching between certain info tabs +- `suspendmanager`: overlays for suspended building info panels no longer disappear when another window has focus + +## Misc Improvements +- `reveal`: automatically reset saved map state when a new save is loaded +- `autonestbox`: don't automatically assign partially trained egg-layers to nestboxes if they don't have an ongoing trainer assigned since they might revert to wild +- `buildingplan`: replace ``[edit filters]`` button in planner overlay with abbreviated filter information + +## API +- ``Units::assignTrainer``: assign a trainer to a trainable animal +- ``Units::unassignTrainer``: unassign a trainer from an animal +- ``Gui::getAnyWorkshopJob``: get the first job associated with the selected workshop +- ``Gui::getAnyJob``: get the job associated with the selected game element (item, unit, workshop, etc.) + +## Lua +- ``dfhack.units.isTamable``: return false for invaders to match vanilla logic +- ``dfhack.units.assignTrainer``: expose API to Lua +- ``dfhack.units.unassignTrainer``: expose API to Lua +- ``dfhack.gui.getAnyWorkshopJob``: expose API to Lua +- ``dfhack.gui.getAnyJob``: expose API to Lua + +## Removed +- ``nopause``: functionality has moved to `spectate` + +# 50.11-r5 + +## New Tools +- `gui/embark-anywhere`: new keybinding (active when choosing an embark site): Ctrl-A + +## New Features +- `sort`: search and sort for the "choose unit to elevate to the barony" screen. units are sorted by the number of item preferences they have and the units are annotated with the items that they have preferences for +- `zone`: add button to location details page for retiring unused locations +- `gui/mass-remove`: new global keybinding: Ctrl-M while on the fort map + +## Fixes +- `reveal`: now avoids revealing blocks that contain divine treasures, encased horrors, and deep vein hollows (so the surprise triggers are not triggered prematurely) +- `sort`: fix mouse clicks falling through the squad assignment overlay panel when clicking on the panel but not on a clickable widget +- `sort`: fix potential crash when removing jobs directly from the Tasks info screen +- `misery`: fix error when changing the misery factor +- When passing map movement keys through to the map from DFHack tool windows, also pass fast z movements (shift-scroll by default) +- `getplants`: fix crash when processing mod-added plants with invalid materials +- Dreamfort: fix holes in the "Inside+" burrow on the farming level (burrow autoexpand is interrupted by the pre-dug miasma vents to the surface) +- ``Maps::getBiomeType``, ``Maps::getBiomeTypeWithRef``: fix identification of tropical oceans +- DFHack tabs (e.g. in `gui/control-panel`) are now rendered correctly when there are certain vanilla screen elements behind them +- `buildingplan`: when you save a game and load it again, newly planned buildings are now correctly placed in line after existing planned buildings of the same type +- `buildingplan`: treat items in wheelbarrows as unavailable, just as vanilla DF does. Make sure the `fix/empty-wheelbarrows` fix is enabled so those items aren't permanently unavailable! +- `buildingplan`: show correct number of materials required when laying down areas of constructions and some of those constructions are on invalid tiles +- `stonesense`: fix crash in cleanup code after mega screenshot (Ctrl-F5) completes; however, the mega screenshot will still make stonesense unresponsive. close and open the stonesense window to continue using it. +- `gui/design`: fix incorrect highlight when box selecting area in ASCII mode +- `fastdwarf`: prevent units from teleporting to inaccessible areas when in teledwarf mode +- `fastdwarf`: allow units to meander and satisfy needs when they have no current job and teledwarf mode is enabled + +## Misc Improvements +- `autochop`: better error output when target burrows are not specified on the commandline +- `autoclothing` : now does not consider worn (x) clothing as usable/available; reduces overproduction when using `tailor` at same time +- `buildingplan`: add option for preventing constructions from being planned on top of existing constructions (e.g. don't build floors on top of floors) +- `burrow`: flood fill now requires an explicit toggle before it is enabled to help prevent accidental flood fills +- wherever units are listed in DFHack tools, properties like "agitated" or (-trained-) are now shown +- `work-now`: now saves its enabled status with the fort +- `fastdwarf`: now saves its state with the fort +- `zone`: add include/only/exclude filter for juveniles to the pasture/pit/cage/restraint assignment screen +- The "PAUSE FORCED" badge will blink briefly to draw attention if the player attempts to unpause when a DFHack tool window requires the game to be paused +- `sort`: add "Toggle all filters" hotkey button to the squad assignment panel +- `sort`: rename "Weak mental fortitude" filter to "Dislikes combat", which should be more understandable +- Dreamfort: put more chairs adjacent to each other to make the tavern more "social" +- `zone`: show geld status and custom profession (if set, it's the lower editable line in creature description) in pasture/pit/cage/restraint assignment screen +- `orders`: reduce prepared meal target and raise booze target in ``basic`` importable orders in the orders library + +## Documentation +- `installing`: Add installation instructions for wineskin on Mac +- UTF-8 text in tool docs is now properly displayed in-game in `gui/launcher` (assuming that it can be converted to cp-437) +- `modding-guide`: Add examples for script-only and blueprint-only mods that you can upload to DF's Steam Workshop +- DFHack developer's guide updated, with refreshed `architectural-diagrams` + +## API +- ``random_index``, ``vector_get_random``: new ``MiscUtils`` functions, for getting a random entry in a vector +- ``capitalize_string_words``: new ``MiscUtils`` function, returns string with all words capitalized +- ``grab_token_string_pos``: new ``MiscUtils`` function, used for parsing tokens +- ``Items``: add item melting logic ``canMelt(item)``, ``markForMelting(item)``, and ``cancelMelting(item)`` +- ``World``: ``GetCurrentSiteId()`` returns the loaded fort site ID (or -1 if no site is loaded) +- ``World``: ``IsSiteLoaded()`` check to detect if a site (e.g. a player fort) is active (as opposed to the world or a map) +- ``World``: ``AddPersistentData`` and related functions replaced with ``AddPersistentSiteData`` and ``AddPersistentWorldData`` equivalents +- New plugin API for saving and loading persistent data. See plugins/examples/skeleton.cpp and plugins/examples/persistent_per_save_example.cpp for details +- Plugin ABI (binary interface) version bump! Any external plugins must be recompiled against this version of DFHack source code in order to load. +- ``Persistence``: persistent keys are now namespaced by an entity_id (e.g. a player fort site ID) +- ``Persistence``: data is now stored one file per entity ID (plus one for the global world) in the DF savegame directory +- ``Units.isDanger``: now returns true for agitated wildlife +- ``Constructions::designateRemove``: no longer designates the non-removable "pseudo" constructions that represent the top of walls + +## Lua +- ``dfhack.capitalizeStringWords``: new function, returns string with all words capitalized +- ``widgets.Divider``: linear divider to split an existing frame; configurable T-junction edges and frame style matching +- ``dfhack.persistent``: new, table-driven API for easier world- and site-associated persistent storage. See the Lua API docs for details. +- ``dfhack.isSiteLoaded``: returns whether a site (e.g. a player fort) is loaded +- ``dfhack.items``: access to ``canMelt(item)``, ``markForMelting(item)``, and ``cancelMelting(item)`` from ``Items`` module +- ``dfhack.world.getCurrentSite``: returns the ``df.world_site`` instance of the currently loaded fort + +## Removed +- ``persist-table``: replaced by new ``dfhack.persistent`` API +- `channel-safely`: (temporarily) removed due to stability issues with the underlying DF API + +# 50.11-r4 + +## Fixes +- `buildingplan`: fix choosing the wrong mechanism (or something that isn't a mechanism) when linking a lever and manually choosing a mechanism, but then canceling the selection +- RemoteServer: don't shut down the socket prematurely, allowing continuing connections from, for example, dfhack-run +- `sort`: fix potential crash when exiting and re-entering a creatures subtab with a search active +- `sort`: prevent keyboard keys from affecting the UI when search is active and multiple keys are hit at once +- `tailor`: fix corner case where existing stock was being ignored, leading to over-ordering + +## Misc Improvements +- `buildingplan`: save magma safe mechanisms for when magma safety is requested when linking levers and pressure plates to targets +- `buildingplan`: when choosing mechanisms for linking levers/pressure plates, filter out unreachable mechanisms +- `sort`: when searching on the Tasks tab, also search the names of the things the task is associated with, such as the name of the stockpile that an item will be stored in + +# 50.11-r3 + +## New Tools +- `burrow`: (reinstated) automatically expand burrows as you dig + +## New Features +- `prospect`: can now give you an estimate of resources from the embark screen. hover the mouse over a potential embark area and run `prospect`. +- `burrow`: integrated 3d box fill and 2d/3d flood fill extensions for burrow painting mode +- `buildingplan`: allow specific mechanisms to be selected when linking levers or pressure plates +- `sort`: military and burrow membership filters for the burrow assignment screen + +## Fixes +- `stockpiles`: hide configure and help buttons when the overlay panel is minimized +- `caravan`: price of vermin swarms correctly adjusted down. a stack of 10000 bees is worth 10, not 10000 +- `sort`: when filtering out already-established temples in the location assignment screen, also filter out the "No specific deity" option if a non-denominational temple has already been established +- RemoteServer: continue to accept connections as long as the listening socket is valid instead of closing the socket after the first disconnect +- `buildingplan`: overlay and filter editor gui now uses ctrl-d to delete the filter to avoid conflict with increasing the filter's minimum quality (shift-x) +- `tailor`: fix crash on Linux where scanned unit is wearing damaged non-clothing (e.g. a crown) + +## Misc Improvements +- `buildingplan`: display how many items are available on the planner panel +- `buildingplan`: make it easier to build single-tile staircases of any shape (up, down, or up/down) +- `sort`: allow searching by profession on the squad assignment page +- `sort`: add search for places screens +- `sort`: add search for work animal assignment screen; allow filtering by military/squad/civilian/burrow +- `sort`: on the squad assignment screen, make effectiveness and potential ratings use the same scale so effectiveness is always less than or equal to potential for a given unit. this way you can also tell when units are approaching their maximum potential +- `sort`: new overlay on the animal assignment screen that shows how many work animals each visible unit already has assigned to them +- `dreamfort`: Inside+ and Clearcutting burrows now automatically created and managed + +## Documentation +- Document the Lua API for the ``dfhack.world`` module + +## API +- ``Gui::revealInDwarfmodeMap``: gained ``highlight`` parameter to control setting the tile highlight on the zoom target +- ``Maps::getWalkableGroup``: get the walkability group of a tile +- ``Units::getReadableName``: now returns the *untranslated* name +- ``Burrows::setAssignedUnit``: now properly handles inactive burrows +- ``Gui::getMousePos``: now takes an optional ``allow_out_of_bounds`` parameter so coordinates can be returned for mouse positions outside of the game map (i.e. in the blank space around the map) +- ``Buildings::completebuild``: used to link a newly created building into the world + +## Lua +- ``dfhack.gui.revealInDwarfmodeMap``: gained ``highlight`` parameter to control setting the tile highlight on the zoom target +- ``dfhack.maps.getWalkableGroup``: get the walkability group of a tile +- ``dfhack.gui.getMousePos``: support new optional ``allow_out_of_bounds`` parameter +- ``gui.FRAME_THIN``: a panel frame suitable for floating tooltips +- ``dfhack.buildings.completebuild``: expose new module API + +# 50.11-r2 + +## New Tools +- `spectate`: (reinstated) automatically follow dwarves, cycling among interesting ones +- `preserve-tombs`: keep tombs assigned to units when they die + +## New Features +- `logistics`: ``automelt`` now optionally supports melting masterworks; click on gear icon on `stockpiles` overlay frame +- `sort`: new search widgets for Info panel tabs, including all "Creatures" subtabs, all "Objects" subtabs, "Tasks", candidate assignment on the "Noble" subtab, and the "Work details" subtab under "Labor" +- `sort`: new search and filter widgets for the "Interrogate" and "Convict" screens under "Justice" +- `sort`: new search widgets for location selection screen (when you're choosing what kind of guildhall or temple to dedicate) +- `sort`: new search widgets for burrow assignment screen and other unit assignment dialogs +- `sort`: new search widgets for artifacts on the world/raid screen +- `sort`: new search widgets for slab engraving menu; can filter for only units that need a slab to prevent rising as a ghost +- `stocks`: hotkey for collapsing all categories on stocks screen + +## Fixes +- `buildingplan`: remove bars of ash, coal, and soap as valid building materials to match v50 rules +- `buildingplan`: fix incorrect required items being displayed sometimes when switching the planner overlay on and off +- `zone`: races without specific child or baby names will now get generic child/baby names instead of an empty string +- `zone`: don't show animal assignment link for cages and restraints linked to dungeon zones (which aren't normally assignable) +- `sort`: don't count mercenaries as appointed officials in the squad assignment screen +- `dwarfvet`: fix invalid job id assigned to ``Rest`` job, which could cause crashes on reload + +## Misc Improvements +- `overlay`: allow ``overlay_onupdate_max_freq_seconds`` to be dynamically set to 0 for a burst of high-frequency updates +- Help icons added to several complex overlays. clicking the icon runs `gui/launcher` with the help text in the help area +- `orders`: ``recheck`` command now only resets orders that have conditions that can be rechecked +- `sort`: added help button for squad assignment search/filter/sort +- `zone`: animals trained for war or hunting are now labeled as such in animal assignment screens +- `buildingplan`: support filtering cages by whether they are occupied +- `buildingplan`: show how many items you need to make when planning buildings +- `tailor`: now adds to existing orders if possible instead of creating new ones + +## Documentation +- unavailable tools are no longer listed in the tag indices in the online docs + +## API +- added ``Items::getCapacity``, returns the capacity of an item as a container (reverse-engineered), needed for `combine` + +## Lua +- added ``GRAY`` color aliases for ``GREY`` colors +- added ``dfhack.items.getCapacity`` to expose the new module API +- ``utils.search_text``: text search routine (generalized from internal ``widgets.FilteredList`` logic) + +## Removed +- ``FILTER_FULL_TEXT``: moved from ``gui.widgets`` to ``utils``; if your full text search preference is lost, please reset it in `gui/control-panel` + +# 50.11-r1 + +## New Tools +- `tubefill`: (reinstated) replenishes mined-out adamantine + +## Fixes +- `autolabor`: ensure vanilla work details are reinstated when the fort or the plugin is unloaded +- ``dfhack.TranslateName()``: fixed crash on certain invalid names, which affected `warn-starving` +- EventManager: Unit death event no longer misfires on units leaving the map + +## Misc Improvements +- `digtype`: designate only visible tiles by default, and use "auto" dig mode for following veins +- `digtype`: added options for designating only current z-level, this z-level and above, and this z-level and below +- `hotkeys`: make the DFHack logo brighten on hover in ascii mode to indicate that it is clickable +- `hotkeys`: use vertical bars instead of "!" symbols for the DFHack logo in ascii mode to make it easier to read +- EventManager: guard against potential iterator invalidation if one of the event listeners were to modify the global data structure being iterated over +- EventManager: for ``onBuildingCreatedDestroyed`` events, changed firing order of events so destroyed events come before created events + +## Lua +- mouse key events are now aligned with internal DF semantics: ``_MOUSE_L`` indicates that the left mouse button has just been pressed and ``_MOUSE_L_DOWN`` indicates that the left mouse button is being held down. similarly for ``_MOUSE_R`` and ``_MOUSE_M``. 3rd party scripts may have to adjust. + +# 50.10-r1 + +## Fixes +- Linux launcher: allow Steam Overlay and game streaming to function +- `autobutcher`: don't ignore semi-wild units when marking units for slaughter + +## Misc Improvements +- 'sort': Improve combat skill scale thresholds + +# 50.09-r4 + +## New Features +- `dig`: new overlay for ASCII mode that visualizes designations for smoothing, engraving, carving tracks, and carving fortifications + +## Fixes +- `buildingplan`: make the construction dimensions readout visible again +- `seedwatch`: fix a crash when reading data saved by very very old versions of the plugin +- `gui/mod-manager`: don't continue to display overlay after the raws loading progress bar appears + +## Misc Improvements +- `sort`: add sort option for training need on squad assignment screen +- `sort`: filter mothers with infants, units with weak mental fortitude, and critically injured units on the squad assignment screen +- `sort`: display a rating relative to the current sort order next to the visible units on the squad assignment screen + +## Documentation +- add instructions for downloading development builds to the ``Installing`` page + +## API +- `overlay`: overlay widgets can now declare a ``version`` attribute. changing the version of a widget will reset its settings to defaults. this is useful when changing the overlay layout and old saved positions will no longer be valid. + +## Lua +- ``argparse.boolean``: convert arguments to lua boolean values. + +# 50.09-r3 + +## New Features +- `sort`: search, sort, and filter for squad assignment screen +- `zone`: advanced unit assignment screens for cages, restraints, and pits/ponds +- `buildingplan`: one-click magma/fire safety filter for planned buildings + +## Fixes +- Core: reload scripts in mods when a world is unloaded and immediately loaded again +- Core: fix text getting added to DFHack text entry widgets when Alt- or Ctrl- keys are hit +- `buildingplan`: ensure selected barrels and buckets are empty (or at least free of lye and milk) as per the requirements of the building +- `orders`: prevent import/export overlay from appearing on the create workorder screen +- `caravan`: corrected prices for cages that have units inside of them +- `tailor`: remove crash caused by clothing items with an invalid ``maker_race`` +- ``dialogs.MessageBox``: fix spacing around scrollable text +- `seedwatch`: ignore unplantable tree seeds +- `autobutcher`: fix ``ticks`` commandline option incorrectly rejecting positive integers as valid values + +## Misc Improvements +- Surround DFHack-specific UI elements with square brackets instead of red-yellow blocks for better readability +- `autobutcher`: don't mark animals for butchering if they are already marked for some kind of training (war, hunt) +- `hotkeys`: don't display DFHack logo in legends mode since it covers up important interface elements. the Ctrl-Shift-C hotkey to bring up the menu and the mouseover hotspot still function, though. +- `sort`: animals are now sortable by race on the assignment screens +- `createitem`: support creating items inside of bags + +## API +- ``Items::getValue()``: remove ``caravan_buying`` parameter since the identity of the selling party doesn't actually affect the item value +- `RemoteFortressReader`: add a ``force_reload`` option to the GetBlockList RPC API to return blocks regardless of whether they have changed since the last request +- ``Units``: new animal property check functions ``isMarkedForTraining(unit)``, ``isMarkedForTaming(unit)``, ``isMarkedForWarTraining(unit)``, and ``isMarkedForHuntTraining(unit)`` +- ``Gui``: ``getAnyStockpile`` and ``getAnyCivzone`` (along with their ``getSelected`` variants) now work through layers of ZScreens. This means that they will still return valid results even if a DFHack tool window is in the foreground. + +## Lua +- ``new()``: improved error handling so that certain errors that were previously uncatchable (creating objects with members with unknown vtables) are now catchable with ``pcall()`` +- ``dfhack.items.getValue()``: remove ``caravan_buying`` param as per C++ API change +- ``widgets.BannerPanel``: panel with distinctive border for marking DFHack UI elements on otherwise vanilla screens +- ``widgets.Panel``: new functions to override instead of setting corresponding properties (useful when subclassing instead of just setting attributes): ``onDragBegin``, ``onDragEnd``, ``onResizeBegin``, ``onResizeEnd`` +- ``dfhack.screen.readTile()``: now populates extended tile property fields (like ``top_of_text``) in the returned ``Pen`` object +- ``dfhack.units``: new animal property check functions ``isMarkedForTraining(unit)``, ``isMarkedForTaming(unit)``, ``isMarkedForWarTraining(unit)``, and ``isMarkedForHuntTraining(unit)`` +- ``dfhack.gui``: new ``getAnyCivZone`` and ``getAnyStockpile`` functions; also behavior of ``getSelectedCivZone`` and ``getSelectedStockpile`` functions has changes as per the related API notes + +# 50.09-r2 + +## New Plugins +- `3dveins`: reinstated for v50, this plugin replaces vanilla DF's blobby vein generation with veins that flow smoothly and naturally between z-levels +- `zone`: new searchable, sortable, filterable screen for assigning units to pastures +- `dwarfvet`: reinstated and updated for v50's new hospital mechanics; allow your animals to have their wounds treated at hospitals +- `dig`: new ``dig.asciiwarmdamp`` overlay that highlights warm and damp tiles when in ASCII mode. there is no effect in graphics mode since the tiles are already highlighted there + +## Fixes +- Fix extra keys appearing in DFHack text boxes when shift (or any other modifier) is released before the other key you were pressing +- `logistics`: don't autotrain domestic animals brought by invaders (they'll get attacked by friendly creatures as soon as you let them out of their cage) +- `logistics`: don't bring trade goods to depot if the only caravans present are tribute caravans +- `gui/create-item`: when choosing a citizen to create the chosen items, avoid choosing a dead citizen +- `logistics`: fix potential crash when removing stockpiles or turning off stockpile features + +## Misc Improvements +- `stockpiles`: include exotic pets in the "tameable" filter +- `logistics`: bring an autotraded bin to the depot if any item inside is tradeable instead of marking all items within the bin as untradeable if any individual item is untradeable +- `autonick`: add more variety to nicknames based on famous literary dwarves +- ``widgets.EditField``: DFHack edit fields now support cut/copy/paste with the system clipboard with Ctrl-X/Ctrl-C/Ctrl-V +- Suppress DF keyboard events when a DFHack keybinding is matched. This prevents, for example, a backtick from appearing in a textbox as text when you launch `gui/launcher` from the backtick keybinding. +- Dreamfort: give noble suites double-thick walls and add apartment doors + +## Documentation +- `misery`: rewrite the documentation to clarify the actual effects of the plugin + +## API +- ``Units::getUnitByNobleRole``, ``Units::getUnitsByNobleRole``: unit lookup API by role +- ``Items::markForTrade()``, ``Items::isRequestedTradeGood()``, ``Items::getValue``: see Lua notes below + +## Internals +- Price calculations fixed for many item types + +## Lua +- ``dfhack.units.getUnitByNobleRole``, ``dfhack.units.getUnitsByNobleRole``: unit lookup API by role +- ``dfhack.items.markForTrade``: mark items for trade +- ``dfhack.items.isRequestedTradeGood``: discover whether an item is named in a trade agreement with an active caravan +- ``dfhack.items.getValue``: gained optional ``caravan`` and ``caravan_buying`` parameters for prices that take trader races and agreements into account +- ``widgets.TextButton``: wraps a ``HotkeyLabel`` and decorates it to look more like a button + +# 50.09-r1 + +## Internals + +- Core: update SDL interface from SDL1 to SDL2 + +# 50.08-r4 + +## New Plugins +- `logistics`: automatically mark and route items or animals that come to monitored stockpiles. options are toggleable on an overlay that comes up when you have a stockpile selected. + +## Fixes +- `buildingplan`: don't include artifacts when max quality is masterful +- `dig-now`: clear item occupancy flags for channeled tiles that had items on them +- `RemoteFortressReader`: fix a crash with engravings with undefined images + +## Misc Improvements +- `autonick`: additional nicknames based on burrowing animals, colours, gems, and minerals +- `stockpiles`: added ``barrels``, ``organic``, ``artifacts``, and ``masterworks`` stockpile presets +- `orders`: only display import/export/sort/clear panel on main orders screen +- `orders`: refine order conditions for library orders to reduce cancellation spam +- Blueprint library: dreamfort: full rewrite and update for DF v50 +- Blueprint library: pump_stack: updated walkthrough and separated dig and channel steps so boulders can be cleared +- Blueprint library: aquifer_tap: updated walkthrough +- `dig-now`: can now handle digging obsidian that has been formed from magma and water + +## Documentation +- `blueprint-library-guide`: update Dreamfort screenshots and links, add ``aquifer_tap`` screenshot + +# 50.08-r3 + +## Fixes +- Fix crash for some players when they launch DF outside of the Steam client + +# 50.08-r2 + +## New Plugins +- `add-spatter`: (reinstated) allow mods to add poisons and magical effects to weapons +- `changeitem`: (reinstated) change item material, quality, and subtype +- `createitem`: (reinstated) create arbitrary items from the command line +- `deramp`: (reinstated) removes all ramps designated for removal from the map +- `flows`: (reinstated) counts map blocks with flowing liquids +- `lair`: (reinstated) mark the map as a monster lair (this avoids item scatter when the fortress is abandoned) +- `luasocket`: (reinstated) provides a Lua API for accessing network sockets +- `work-now`: (reinstated, renamed from ``workNow``) prevent dwarves from wandering aimlessly with "No job" after completing a task + +## Fixes +- DFHack screen backgrounds now use appropriate tiles in DF Classic +- RemoteServer: fix crash on malformed json in ``dfhack-config/remote-server.json`` +- `autolabor`: work detail override warning now only appears on the work details screen +- `RemoteFortressReader`: ensured names are transmitted in UTF-8 instead of CP437 + +## Misc Improvements +- `autodump`: no longer checks for a keyboard cursor before executing, so ``autodump destroy`` (which doesn't require a cursor) can still function +- Settings: recover gracefully when settings files become corrupted (e.g. by DF CTD) +- `orders`: update orders in library for prepared meals, bins, archer uniforms, and weapons +- `gui/control-panel`: new preference for whether filters in lists search for substrings in the middle of words (e.g. if set to true, then "ee" will match "steel") +- `gui/design`: Improved performance for drawing shapes +- Dreamfort: improve traffic patterns throughout the fortress +- `gui/blueprint`: recording of stockpile layouts and categories is now supported. note that detailed stockpile configurations will *not* be saved (yet) +- Core: new commandline flag/environment var: pass ``--disable-dfhack`` on the Dwarf Fortress commandline or specify ``DFHACK_DISABLE=1`` in the environment to disable DFHack for the current session. +- `overlay`: add links to the quickstart guide and the control panel on the DF title screen +- Window behavior: non-resizable windows now allow dragging by their frame edges by default +- `gui/autodump`: fort-mode keybinding: Ctrl-H (when ``armok`` tools are enabled in `gui/control-panel`) +- Window behavior: if you have multiple DFHack tool windows open, scrolling the mouse wheel while over an unfocused window will focus it and raise it to the top +- `stockpiles`: allow filtering creatures by tameability + +## Internals +- ``dfhack.internal``: added memory analysis functions: ``msizeAddress``, ``getHeapState``, ``heapTakeSnapshot``, ``isAddressInHeap``, ``isAddressActiveInHeap``, ``isAddressUsedAfterFreeInHeap``, ``getAddressSizeInHeap``, and ``getRootAddressOfHeapObject`` + +## Lua +- ``overlay.reload()``: has been renamed to ``overlay.rescan()`` so as not to conflict with the global ``reload()`` function. If you are developing an overlay, please take note of the new function name for reloading your overlay during development. +- ``gui``: changed frame naming scheme to ``FRAME_X`` rather than ``X_FRAME``, and added aliases for backwards compatibility. (for example ``BOLD_FRAME`` is now called ``FRAME_BOLD``) +- ``ensure_keys``: walks a series of keys, creating new tables for any missing values + +## Removed +- `orders`: ``library/military_include_artifact_materials`` library file removed since recent research indicates that platinum blunt weapons and silver crossbows are not more effective than standard steel. the alternate military orders file was also causing unneeded confusion. + +# 50.08-r1 + +## Fixes +- `autoclothing`: eliminate game lag when there are many inventory items in the fort +- `buildingplan`: fixed size limit calculations for rollers +- `buildingplan`: fixed items not being checked for accessibility in the filter and item selection dialogs +- `dig-now`: properly detect and complete smoothing designations that have been converted into active jobs + +## Misc Improvements +- `buildingplan`: planner panel is minimized by default and now remembers minimized state +- `buildingplan`: can now filter by gems (for gem windows) and yarn (for ropes in wells) +- ``toggle-kbd-cursor``: add hotkey for toggling the keyboard cursor (Alt-K) +- ``version``: add alias to display the DFHack help (including the version number) so something happens when players try to run "version" +- `gui/control-panel`: add preference option for hiding the terminal console on startup +- `gui/control-panel`: add preference option for hiding "armok" tools in command lists +- ``Dwarf Therapist``: add a warning to the Labors screen when Dwarf Therapist is active so players know that changes they make to that screen will have no effect. If you're starting a new embark and nobody seems to be doing anything, check your Labors tab for this warning to see if Dwarf Therapist thinks it is in control (even if it's not running). +- `overlay`: add the DFHack version string to the DF title screen + +## Lua +- ``widgets.RangeSlider``: new mouse-controlled two-headed slider widget +- ``gui.ZScreenModal``: ZScreen subclass for modal dialogs +- ``widgets.CycleHotkeyLabel``: exposed "key_sep" and "option_gap" attributes for improved stylistic control. + +## Removed +- `title-version`: replaced by an `overlay` widget + +# 50.07-r1 + +## New Plugins +- `faststart`: speeds up the "Loading..." screen so the Main Menu appears faster + +## Fixes +-@ `hotkeys`: hotkey hints on menu popup will no longer get their last character cut off by the scrollbar +-@ ``launchdf``: launch Dwarf Fortress via the Steam client so Steam Workshop is functional +- `blueprint`: interpret saplings, shrubs, and twigs as floors instead of walls +- `combine`: fix error processing stockpiles with boundaries that extend outside of the map +-@ `prospector`: display both "raw" Z levels and "cooked" elevations +- `stockpiles`: fix crash when importing settings for gems from other worlds +-@ `stockpiles`: allow numbers in saved stockpile filenames + +## Misc Improvements +-@ `buildingplan`: items in the item selection dialog should now use the same item quality symbols as the base game +-@ `buildingplan`: hide planner overlay while the DF tutorial is active so that it can detect when you have placed the carpenter's workshop and bed and allow you to finish the tutorial +- `buildingplan`: can now filter by cloth and silk materials (for ropes) +-@ `buildingplan`: rearranged elements of ``planneroverlay`` interface +-@ `buildingplan`: rearranged elements of ``itemselection`` interface +-@ Mods: scripts in mods that are only in the steam workshop directory are now accessible. this means that a script-only mod that you never mark as "active" when generating a world will still receive automatic updates and be usable from in-game +-@ Mods: scripts from only the most recent version of an installed mod are added to the script path +-@ Mods: give active mods a chance to reattach their load hooks when a world is reloaded +- `gui/control-panel`: bugfix services are now enabled by default +- Core: hide DFHack terminal console by default when running on Steam Deck + +## Documentation +- `installing`: updated to include Steam installation instructions + +## Lua +- added two new window borders: ``gui.BOLD_FRAME`` for accented elements and ``gui.INTERIOR_MEDIUM_FRAME`` for a signature-less frame that's thicker than the existing ``gui.INTERIOR_FRAME`` + +# 50.07-beta2 + +## New Plugins +- `getplants`: reinstated: designate trees for chopping and shrubs for gathering according to type +- `prospector`: reinstated: get stone, ore, gem, and other tile property counts in fort mode. + +## Fixes +-@ `buildingplan`: filters are now properly applied to planned stairs +-@ `buildingplan`: existing carved up/down stairs are now taken into account when determining which stair shape to construct +- `buildingplan`: upright spike traps are now placed extended rather than retracted +- `buildingplan`: you can no longer designate constructions on tiles with magma or deep water, mirroring the vanilla restrictions +-@ `buildingplan`: fixed material filters getting lost for planning buildings on save/reload +-@ `buildingplan`: respect building size limits (e.g. roads and bridges cannot be more than 31 tiles in any dimension) +- `tailor`: properly discriminate between dyed and undyed cloth +-@ `tailor`: no longer default to using adamantine cloth for producing clothes +- `tailor`: take queued orders into account when calculating available materials +- `tailor`: skip units who can't wear clothes +- `tailor`: identify more available items as available, solving issues with over-production + +## Misc Improvements +- `buildingplan`: filters and global settings are now ignored when manually choosing items for a building, allowing you to make custom choices independently of the filters that would otherwise be used +- `buildingplan`: if `suspendmanager` is running, then planned buildings will be left suspended when their items are all attached. `suspendmanager` will unsuspend them for construction when it is safe to do so. +- `buildingplan`: add option for autoselecting the last manually chosen item (like `automaterial` used to do) +- `confirm`: adds confirmation for removing burrows via the repaint menu +- `stockpiles`: support applying stockpile configurations with fully enabled categories to stockpiles in worlds other than the one where the configuration was exported from +- `stockpiles`: support partial application of a saved config based on dynamic filtering (e.g. disable all tallow in a food stockpile, even tallow from world-specific generated creatures) +- `stockpiles`: additive and subtractive modes when applying a second stockpile configuration on top of a first +- `stockpiles`: write player-exported stockpile configurations to the ``dfhack-config/stockpiles`` folder. If you have any stockpile configs in other directories, please move them to that folder. +- `stockpiles`: now includes a library of useful stockpile configs (see docs for details) +- `automelt`: now allows metal chests to be melted (workaround for DF bug 2493 is no longer needed) +- `orders`: add minimize button to overlay panel so you can get it out of the way to read long statue descriptions when choosing a subject in the details screen +- `orders`: add option to delete exported files from the import dialog +- `enable`: can now interpret aliases defined with the `alias` command +- Mods: scripts in mods are now automatically added to the DFHack script path. DFHack recognizes two directories in a mod's folder: ``scripts_modinstalled/`` and ``scripts_modactive/``. ``scripts_modinstalled/`` folders will always be added the script path, regardless of whether the mod is active in a world. ``scripts_modactive/`` folders will only be added to the script path when the mod is active in the current loaded world. + +## Documentation +- `modding-guide`: guide updated to include information for 3rd party script developers +- the ``untested`` tag has been renamed to ``unavailable`` to better reflect the status of the remaining unavailable tools. most of the simply "untested" tools have now been tested and marked as working. the remaining tools are known to need development work before they are available again. + +## Lua +- ``widgets.Label``: tokens can now specify a ``htile`` property to indicate the tile that should be shown when the Label is hovered over with the mouse +- ``widgets.Label``: click handlers no longer get the label itself as the first param to the click handler +- ``widgets.CycleHotkeyLabel``: options that are bare integers will no longer be interpreted as the pen color in addition to being the label and value +- ``widgets.CycleHotkeyLabel``: option labels and pens can now be functions that return a label or pen + +# 50.07-beta1 + +## Fixes +-@ `buildingplan`: items are now attached correctly to screw pumps and other multi-item buildings +-@ `buildingplan`: buildings with different material filters will no longer get "stuck" if one of the filters currently matches no items +- `showmood` properly count required number of bars and cloth when they aren't the main item for the strange mood + +## Misc Improvements +-@ `buildingplan`: can now filter by clay materials +-@ `buildingplan`: remember choice per building type for whether the player wants to choose specific items +-@ `buildingplan`: you can now attach multiple weapons to spike traps +-@ `buildingplan`: can now filter by whether a slab is engraved +-@ `buildingplan`: add "minimize" button to temporarily get the planner overlay out of the way if you would rather use the vanilla UI for placing the current building +-@ `buildingplan`: add ``buildingplan reset`` command for resetting all filters to defaults +-@ `buildingplan`: rename "Build" button to "Confirm" on the item selection dialog and change the hotkey from "B" to "C" +- `blueprint`: now writes blueprints to the ``dfhack-config/blueprints`` directory +- `blueprint-library-guide`: library blueprints have moved from ``blueprints`` to ``hack/data/blueprints`` +- `blueprint-library-guide`: player-created blueprints should now go in the ``dfhack-config/blueprints`` folder. please move your existing blueprints from ``blueprints`` to ``dfhack-config/blueprints``. you don't need to move the library blueprints -- those can be safely deleted from the old ``blueprints`` directory. +-@ `showmood`: clarify how many bars and/or cloth items are actually needed for the mood + +## Removed +-@ `buildingplan`: "heat safety" setting is temporarily removed while we investigate incorrect item matching + +# 50.07-alpha3 + +## Fixes +-@ ``widgets.HotkeyLabel``: don't trigger on click if the widget is disabled +- ``dfhack.job.isSuitableMaterial``: now properly detects lack of fire and magma safety for vulnerable materials with high melting points +- `dig-now`: fixed multi-layer channel designations only channeling every second layer + +## Misc Improvements +- `dig-now`: added handling of dig designations that have been converted into active jobs +- `buildingplan`: entirely new UI for building placement, item selection, and materials filtering! + +## API +- Gui focus strings will no longer get the "dfhack/" prefix if the string "dfhack/" already exists in the focus string +- ``Military``: New module for military functionality +- ``Military``: new ``makeSquad`` to create a squad +- ``Military``: changed ``getSquadName`` to take a squad identifier +- ``Military``: new ``updateRoomAssignments`` for assigning a squad to a barracks and archery range +- ``Maps::GetBiomeType`` renamed to ``Maps::getBiomeType`` for consistency +- ``Maps::GetBiomeTypeRef`` renamed to ``Maps::getBiomeTypeRef`` for consistency + +## Lua +- ``dfhack.job.attachJobItem()``: allows you to attach specific items to a job +- ``dfhack.screen.paintTile()``: you can now explicitly clear the interface cursor from a map tile by passing ``0`` as the tile value +- ``widgets.Label``: token ``tile`` properties can now be functions that return a value +- ``widgets.CycleHotkeyLabel``: add ``label_below`` attribute for compact 2-line output +-@ ``widgets.FilteredList``: search key matching is now case insensitive by default +-@ ``gui.INTERIOR_FRAME``: a panel frame style for use in highlighting off interior areas of a UI +- ``maps.getBiomeType``: exposed preexisting function to Lua + +## Removed +-@ ``gui.THIN_FRAME``: replaced by ``gui.INTERIOR_FRAME`` +- `automaterial`: all functionality has been merged into `buildingplan` + +# 50.07-alpha2 + +## Fixes +-@ `nestboxes`: fixed bug causing nestboxes themselves to be forbidden, which prevented citizens from using them to lay eggs. Now only eggs are forbidden. +-@ `autobutcher`: implemented work-around for Dwarf Fortress not setting nicknames properly, so that nicknames created in the in-game interface are detected & protect animals from being butchered properly. Note that nicknames for unnamed units are not currently saved by dwarf fortress - use ``enable fix/protect-nicks`` to fix any nicknames created/removed within dwarf fortress so they can be saved/reloaded when you reload the game. +-@ `seedwatch`: fix saving and loading of seed stock targets +- `autodump`: changed behaviour to only change ``dump`` and ``forbid`` flags if an item is successfully dumped. +-@ `autochop`: generate default names for burrows with no assigned names +- ``Buildings::StockpileIterator``: fix check for stockpile items on block boundary. +- `tailor`: block making clothing sized for toads; make replacement clothing orders use the size of the wearer, not the size of the garment +-@ `confirm`: fix fps drop when enabled +-@ `channel-safely`: fix an out of bounds error regarding the REPORT event listener receiving (presumably) stale id's + +## Misc Improvements +- `autobutcher`: logs activity to the console terminal instead of making disruptive in-game announcements +- DFHack tool windows that capture mouse clicks (and therefore prevent you from clicking on the "pause" button) now unconditionally pause the game when they open (but you can still unpause with the keyboard if you want to). Examples of this behavior: `gui/quickfort`, `gui/blueprint`, `gui/liquids` +- `showmood`: now shows the number of items needed for cloth and bars in addition to the technically correct but always confusing "total dimension" (150 per bar or 10,000 per cloth) +-@ Stopped mouse clicks from affecting the map when a click on a DFHack screen dismisses the window +- `confirm`: configuration data is now persisted globally. +- `tailor`: add support for adamantine cloth (off by default); improve logging + +## API +- ``Gui::any_civzone_hotkey``, ``Gui::getAnyCivZone``, ``Gui::getSelectedCivZone``: new functions to operate on the new zone system +- Units module: added new predicates for ``isGeldable()``, ``isMarkedForGelding()``, and ``isPet()`` + +## Lua +- ``dfhack.gui.getSelectedCivZone``: returns the Zone that the user has selected currently +- ``widgets.FilteredList``: Added ``edit_on_change`` optional parameter to allow a custom callback on filter edit change. +- ``widgets.TabBar``: new library widget (migrated from control-panel.lua) + +# 50.07-alpha1 + +## Fixes +- ``Units::isFortControlled``: Account for agitated wildlife +-@ Fix right click sometimes closing both a DFHack window and a vanilla panel +-@ Fixed issue with scrollable lists having some data off-screen if they were scrolled before being made visible +-@ `channel-safely`: fixed bug resulting in marker mode never being set for any designation +-@ `automelt`: fixed bug related to lua stack smashing behavior in returned stockpile configs +-@ `autochop`: fixed bug related to lua stack smashing behavior in returned stockpile configs +-@ `nestboxes`: now cancels any in-progress hauling jobs when it protects a fertile egg +-@ Fix persisted data not being written on manual save +-@ `nestboxes`: now scans for eggs more frequently and cancels any in-progress hauling jobs when it protects a fertile egg + +## Misc Improvements +-@ `automelt`: is now more resistent to vanilla savegame corruption +-@ `hotkeys`: DFHack logo is now hidden on screens where it covers important information when in the default position (e.g. when choosing an embark site) +- `misery`: now persists state with the fort +-@ `autodump`: reinstate ``autodump-destroy-item``, hotkey: Ctrl-K +- `autodump`: new hotkey for ``autodump-destroy-here``: Ctrl-H +-@ `dig`: new hotkeys for vein designation on z-level (Ctrl-V) and vein designation across z-levels (Ctrl-Shift-V) +-@ `clean`: new hotkey for `spotclean`: Ctrl-C +- `autobutcher`: changed defaults from 5 females / 1 male to 4 females / 2 males so a single unfortunate accident doesn't leave players without a mating pair +- `autobutcher`: now immediately loads races available at game start into the watchlist +-@ replaced DFHack logo used for the hover hotspot with a crisper image +-@ `orders`: recipe for silver crossbows removed from ``library/military`` as it is not a vanilla recipe, but is available in ``library/military_include_artifact_materials`` +- `stonesense`: added an ``INVERT_MOUSE_Z`` option to invert the mouse wheel direction + +## Documentation + +## API + +## Lua +- `overlay`: overlay widgets can now specify focus paths for the viewscreens they attach to so they only appear in specific contexts. see `overlay-dev-guide` for details. +- ``widgets.CycleHotkeyLabel``: Added ``key_back`` optional parameter to cycle backwards. +- ``widgets.HotkeyLabel``: Added ``setLabel`` method to allow easily updating the label text without mangling the keyboard shortcut. +- ``widgets.HotkeyLabel``: Added ``setOnActivate`` method to allow easily updating the ``on_activate`` callback. +- ``widgets.FilteredList``: Added ``case_sensitive`` optional parameter to determine if filtering is case sensitive. + +# 50.05-alpha3.1 + +## Fixes +-@ `seedwatch`: fix parameter parsing when setting targets + +# 50.05-alpha3 + +## New Plugins +- `autoslab`: automatically create work orders to engrave slabs for ghostly dwarves + +## Fixes +-@ DF screens can no longer get "stuck" on transitions when DFHack tool windows are visible. Instead, those DF screens are force-paused while DFHack windows are visible so the player can close them first and not corrupt the screen sequence. The "PAUSE FORCED" indicator will appear on these DFHack windows to indicate what is happening. +-@ allow launcher tools to launch themselves without hanging the game +-@ fix issues with clicks "passing through" some DFHack window elements to the screen below +- `getplants`: trees are now designated correctly +- `autoclothing`: fixed a crash that can happen when units are holding invalid items. +-@ `orders`: fix orders in library/basic that create bags +- `orders`: library/military now sticks to vanilla rules and does not add orders for normally-mood-only platinum weapons. A new library orders file ``library/military_include_artifact_materials`` is now offered as an alternate ``library/military`` set of orders that still includes the platinum weapons. +- `autochop`: fixed a crash when processing trees with corrupt data structures (e.g. when a trunk tile fails to fall when the rest of the tree is chopped down) + +## Misc Improvements +-@ DFHack windows can now be "defocused" by clicking somewhere not over the tool window. This has the same effect as pinning previously did, but without the extra clicking. +- `getplants`: ID values will now be accepted regardless of case +-@ Windows now display "PAUSE FORCED" on the lower border if the tool is forcing the game to pause +-@ New borders for DFHack tool windows -- tell us what you think! +-@ `autoclothing`: merged the two separate reports into the same command. +- `automelt`: stockpile configuration can now be set from the commandline +- `channel-safely`: new monitoring for cave-in prevention +-@ `gui/control-panel`: you can now configure whether DFHack tool windows should pause the game by default +- `gui/control-panel`: new global hotkey for quick access: Ctrl-Shift-E +-@ `hotkeys`: clicking on the DFHack logo no longer closes the popup menu +- `nestboxes`: now saves enabled state in your savegame +- `gui/launcher`: sped up initialization time for faster window appearance +- `orders`: orders plugin functionality is now accessible via an `overlay` widget when the manager orders screen is open +- `gui/quickcmd`: now has its own global keybinding for your convenience: Ctrl-Shift-A +- `seedwatch`: now persists enabled state in the savegame, automatically loads useful defaults, and respects reachability when counting available seeds +-@ `quickfort`: planned buildings are now properly attached to any pertinent overlapping zones + +## Documentation +- `compile`: instructions added for cross-compiling DFHack for Windows from a Linux Docker builder +-@ Quickstart guide has been updated with info on new window behavior and how to use the control panel + +## API +- ``Buildings::containsTile()``: no longer takes a ``room`` parameter since that's not how rooms work anymore. If the building has extents, the extents will be checked. otherwise, the result just depends on whether the tile is within the building's bounding box. +- ``Units::getCitizens()``: gets a list of citizens, which otherwise you'd have to iterate over all units the world to discover +- ``Screen::Pen``: now accepts ``top_of_text`` and ``bottom_of_text`` properties to support offset text in graphics mode +- `overlay`: overlay widgets can now specify a default enabled state if they are not already set in the player's overlay config file +- ``Lua::Push``: now supports ``std::unordered_map`` + +## Lua +- `helpdb`: new function: ``helpdb.refresh()`` to force a refresh of the database. Call if you are a developer adding new scripts, loading new plugins, or changing help text during play +- `helpdb`: changed from auto-refreshing every 60 seconds to only refreshing on explicit call to ``helpdb.refresh()``. docs very rarely change during a play session, and the automatic database refreshes were slowing down the startup of `gui/launcher` and anything else that displays help text. +- ``widgets.Label``: ``label.scroll()`` now understands ``home`` and ``end`` keywords for scrolling to the top or bottom +- ``widgets.List``: new callbacks for double click and shift double click +- ``dfhack.units.getCitizens()``: gets a list of citizens +-@ ``gui.ZScreen``: new attribute: ``defocusable`` for controlling whether a window loses keyboard focus when the map is clicked +- ``widgets.Label``: token ``tile`` properties can now be either pens or numeric texture ids +- `tiletypes`: now has a Lua API! ``tiletypes_setTile`` + +## Removed +- `autohauler`: no plans to port to v50, as it just doesn't make sense with the new work detail system + +# 50.05-alpha2 + +## Fixes +-@ `autofarm`: don't duplicate status line entries for crops with no current supply +-@ `orders`: allow the orders library to be listed and imported properly (if you previously copied the orders library into your ``dfhack-config/orders`` directory to work around this bug, you can remove those files now) +- `tailor`: now respects the setting of the "used dyed clothing" standing order toggle + +# 50.05-alpha1 + +## Fixes +- ``widgets.WrappedLabel``: no longer resets scroll position when window is moved or resized + +## Misc Improvements +- Scrollable widgets now react to mouse wheel events when the mouse is over the widget +- the ``dfhack-config/scripts/`` folder is now searched for scripts by default +- `hotkeys`: overlay hotspot widget now shows the DFHack logo in graphics mode and "DFHack" in text mode +- `script-paths`: removed "raw" directories from default script paths. now the default locations to search for scripts are ``dfhack-config/scripts``, ``save/*/scripts``, and ``hack/scripts`` +- ``init.d``: directories have moved from the ``raw`` subfolder (which no longer exists) to the root of the main DF folder or a savegame folder + +## Documentation +- `overlay-dev-guide`: added troubleshooting tips and common development workflows +- added DFHack architecture diagrams to the dev intro +- added DFHack Quickstart guide + +## API +- ``Gui::getDwarfmodeDims``: now only returns map viewport dimensions; menu dimensions are obsolete +- ``Gui::getDFViewscreen``: returns the topmost underlying DF viewscreen +- ``Screen::Pen``: now accepts ``keep_lower`` and ``write_to_lower`` properties to support foreground and background textures in graphics mode + +## Lua +- Removed ``os.execute()`` and ``io.popen()`` built-in functions +- ``gui.View``: ``visible`` and ``active`` can now be functions that return a boolean +- ``widgets.Panel``: new attributes to control window dragging and resizing with mouse or keyboard +- ``widgets.Window``: Panel subclass with attributes preset for top-level windows +- ``widgets.CycleHotkeyLabel``: now supports rendering option labels in the color of your choice +- ``widgets.CycleHotkeyLabel``: new functions ``setOption()`` and ``getOptionPen()`` +- ``widgets.ToggleHotkeyLabel``: now renders the ``On`` option in green text +- ``widgets.Label``: tiles can now have an associated width +- `overlay`: ``OverlayWidget`` now inherits from ``Panel`` instead of ``Widget`` to get all the frame and mouse integration goodies +- ``dfhack.gui.getDFViewscreen()``: returns the topmost underlying DF viewscreen +- ``gui.ZScreen``: Screen subclass that implements window raising, multi-viewscreen input handling, and viewscreen event pass-through so the underlying map can be interacted with and dragged around while DFHack screens are visible +- ``gui.View``: new function ``view:getMouseFramePos()`` for detecting whether the mouse is within (or over) the exterior frame of a view +- ``gui.CLEAR_PEN``: now clears the background and foreground and writes to the background (before it would always write to the foreground) +- ``gui.KEEP_LOWER_PEN``: a general use pen that writes associated tiles to the foreground while keeping the existing background + +## Removed +- ``fix-job-postings`` from the `workflow` plugin is now obsolete since affected savegames can no longer be loaded +- Ruby is no longer a supported DFHack scripting language diff --git a/docs/Binpatches.rst b/docs/dev/Binpatches.rst similarity index 84% rename from docs/Binpatches.rst rename to docs/dev/Binpatches.rst index 53e1455b45..d59b1f8482 100644 --- a/docs/Binpatches.rst +++ b/docs/dev/Binpatches.rst @@ -13,23 +13,23 @@ the `binpatch` command. We recommend using a script or plugin instead of a raw patch if at all possible - that way your work will work for many versions - across multiple operating systems. There's a reason nobody has - written patches since ``0.34.11``! + across multiple operating systems. -.. contents:: +.. contents:: Contents + :local: Getting a patch =============== -There are no binary patches available for Dwarf Fortress versions after 0.34.11 +There are no binary patches available for Dwarf Fortress versions after 0.34.11. This system is kept for the chance that someone will find it useful, so some hints on how to write your own follow. This will require disassembly and -decent skill in `memory research `. +decent skill in `memory research `. * The patches are expected to be encoded in text format used by IDA. -* See :commit:`8a9e3d1a728` for examples. +* See `the patches folder in commit b0e1b51 `_ for examples. * :issue:`546` is about the future of the binpatches, and may be useful reading. @@ -50,10 +50,20 @@ directly in memory at runtime:: If the name of the patch has no extension or directory separators, the script uses :file:`hack/patches//.dif`, thus auto-selecting -the version appropriate for the currently loaded executable. +the version appropriate for the currently loaded executable. The ``df-version`` +is the version string in the loaded symbol table. For example, if you want to +make a patch for all distributed verisons of DF 51.05, you'd provide a ``dif`` +file in each of the following directories: + +- :file:`hack/patches/v0.51.05 linux64 CLASSIC/mypatch.dif` +- :file:`hack/patches/v0.51.05 linux64 ITCH/mypatch.dif` +- :file:`hack/patches/v0.51.05 linux64 STEAM/mypatch.dif` +- :file:`hack/patches/v0.51.05 win64 CLASSIC/mypatch.dif` +- :file:`hack/patches/v0.51.05 win64 ITCH/mypatch.dif` +- :file:`hack/patches/v0.51.05 win64 STEAM/mypatch.dif` This is the preferred method; it's easier to debug, does not cause persistent -problems, and leaves file checksums alone. As with many other commands, users +problems, and leaves file checksums alone. As with many other commands, users can simply add it to `dfhack.init` to reapply the patch every time DF is run. @@ -80,7 +90,9 @@ system console: If you use a permanent patch under OSX or Linux, you must update ``symbols.xml`` with the new checksum of the executable. Find the relevant -section, and add a new line:: +section, and add a new line: + +.. code-block:: xml @@ -153,7 +165,7 @@ gui/assign-rack Bind to a key (the example config uses :kbd:`P`), and activate when viewing a weapon rack in the :kbd:`q` mode. -.. image:: images/assign-rack.png +.. image:: /docs/images/assign-rack.png This script is part of a group of related fixes to make the armory storage work again. The existing issues are: @@ -173,4 +185,3 @@ The script interface simply lets you designate one of the squads that are assigned to the barracks/armory containing the selected stand as the intended user. In order to aid in the choice, it shows the number of currently assigned racks for every valid squad. - diff --git a/docs/dev/Contributing.rst b/docs/dev/Contributing.rst new file mode 100644 index 0000000000..216d204969 --- /dev/null +++ b/docs/dev/Contributing.rst @@ -0,0 +1,165 @@ +.. _contributing: + +########################### +How to contribute to DFHack +########################### + +.. contents:: Contents + :local: + +.. _contributing-code: + +Contributing Code +================= + +DFHack's source code is hosted on GitHub. To obtain the code, you do not need an +account - see the `compilation instructions ` for +details. However, to contribute code to DFHack, you will need a GitHub account +to submit pull requests. DFHack consists of several repositories, so you will +need to fork the repository (or repositories) containing the code you wish to +modify. GitHub has several documentation pages on these topics, including: + +* `An overview of forks + `__ +* `Proposing changes with pull requests + `__ + (note: see `contributing-pr-guidelines` for some DFHack-specific information) + +In general, if you are not sure where or how to make a change, or would like +advice before attempting to make a change, please see `support` for ways to +contact maintainers. If you are interested in addressing an issue reported on the +:issue:`issue tracker <>`, you can start a discussion there if you prefer. + +The sections below cover some guidelines that contributions should follow: + +.. contents:: + :local: + +General contribution guidelines +------------------------------- +* If convenient, compile on multiple platforms when changing anything that + compiles. Our CI should catch anything that fails to build, but checking in + advance can sometimes let you know of any issues sooner. +* Update documentation when applicable - see `docs-standards` for details. +* Update ``docs/changelog.txt`` and ``docs/about/Authors.rst`` when applicable. See + `build-changelog` for more information on the changelog format. +* Submit ideas and bug reports as :issue:`issues on GitHub <>`. + Posts in the forum thread or on Discord can easily get missed or forgotten. +* Work on :issue:`reported problems ` + will take priority over ideas or suggestions. + +Code format +----------- +* Four space indents for C++. Never use tabs for indentation in any language. +* LF (Unix style) line terminators +* No trailing whitespace +* UTF-8 encoding +* For C++: + + * Opening and closing braces on their own lines or opening brace at the end of the previous line + * Braces placed at original indent level if on their own lines + * ``#include`` directives should be sorted: C++ libraries first, then DFHack modules, then ``df/`` headers, + then local includes. Within each category they should be sorted alphabetically. + +General C++ code guidelines +--------------------------- +* This project is currently built at the C++20 feature level, and C++20 features should be used when appropriate. C++23 features will be allowed once all of our build platforms support them. +* NEVER use ``using namespace`` in a header file. In source files, do not use ``using namespace std``; instead, import each STL identifier you need specifically (e.g. ``using std::string;``). +* Avoid platform specific code as much as possible. +* Avoid including ``Windows.h``; if you must, ensure that ``NOMINMAX`` and ``WIN32_LEAN_AND_MEAN`` are defined before including it. +* Do not include C headers (e.g. ````); use the C++ versions (e.g. ````) instead. +* Do not use ``std::string`` (or ``char *``) for path names; always use ``std::filesystem::path``. This avoids issues with encoding, especially on the Windows platform, which is roughly 80% of our user base. +* Do not use ``printf`` or similar functions for formatting strings; use C++ streams or ``fmt::format`` instead. We use the `fmt library `__ for formatting strings; this dependency is automatically fetched by our build system. +* Avoid out parameters; prefer returning a struct, pair, or tuple, or using ``std::optional`` instead. +* Prefer range for loops to traditional for loops when iterating over a container. +* Avoid macros when possible; prefer ``constexpr`` variables for constants and functions or templates for code generation. + +.. _contributing-pr-guidelines: + +Pull request guidelines +----------------------- + +* Pull requests should be based on (and submitted to) the default branch of the + relevant repo, which is the branch you see when you access the repo on GitHub + or clone the repo without specifying a branch. As of 0.47.04-r1, this is + ``develop`` for the main DFHack repo and ``master`` for other repos. +* We often leave feedback as comments on pull requests, so be sure that you have + `notifications turned on `__ or + that you check back for feedback periodically. +* Use a new branch for each feature or bugfix so that your changes can be merged + independently (i.e. not the ``master`` or ``develop`` branch of your fork). + + * An exception: for a collection of small miscellaneous changes (e.g. + structures research), one branch instead of many small branches is fine. It + is still preferred that this branch be dedicated to this purpose, i.e. not + ``master`` or ``develop``. Your pull request may be merged at any point + unless you indicate that it isn't ready (see below), but you can continue to + push to the same branch and open new pull requests as needed. + +* Our continuous integration (CI) will perform certain automatic checks, + ensuring that your code conforms to the code format described above. It is + recommended to install `pre-commit `__ (e.g. using + your distribution's package manager, if on Linux, or using ``pip``) and enable + it by running ``pre-commit install`` from the top-level of any repository from + which you plan to create pull requests. This will perform those checks when + you create the commit locally, allowing you to fix any style issues before + creating the actual pull request. + +* Try to keep pull requests relatively small so that they are easier to review + and merge. + + * If you expect to make a large number of related additions or changes (e.g. + adding a large new plugin), multiple PRs are preferred, as they allow more + frequent (and easier) feedback. If development of this feature is expected + to take a while, we may create a dedicated branch to merge your pull + requests into instead of the repo's default branch. + +* If you plan to make additional changes to your pull request in the near + future, or if it isn't quite ready to be merged, mark it as a + `draft pull request `_ + or add "WIP" to the title. Otherwise, your pull request may be reviewed and/or + merged prematurely. + +* Avoid using force pushes to your pull request branch after it has been reviewed, + as this can make it difficult for reviewers to see what has changed since their + last review. If you need to make changes, consider creating a new commit instead + of amending or rebasing. We neither enforce nor recommend a "single commit" rule; if you do + choose to squash your commits, please ensure that the commit message is clear and descriptive of the changes made. + If your pull request has an unusually large number of commits, a maintainer may + request that you squash your commits into a smaller number of commits before merging. + +* All pull requests must be accompanied by a description of the changes made, and + any relevant information for reviewers. If your pull request addresses an + issue, please include a reference to that issue in the description (e.g. + "Fixes #1234"). If your pull request is related to another pull request, please + include a reference to that pull request in the description (e.g. "Related to + #1234"). + +* All pull requests which have user facing changes, including all new features, bug fixes, or + changes to existing functionality, must include an entry in the "Future" section of + the changelog for the relevant repository. If your pull request is merged, this entry + will be added to the appropriate changelog. These entries are used when preparing the release + notes for each release, so please be sure to include a clear and concise description + of the changes made. See `build-changelog` for more information on the changelog format. + Changes that do not require a changelog entry are mainly those that are purely internal, + such as refactoring not intended to change semantics, code cleanup, changes to CI implementation + or to documentation, or changes directly related to the release process. When in doubt, + assume a changelog entry will be required. + +* Pull requests that add or modify tools must include a corresponding update to the documentation + for that tool. Similarly, pull requests that add or modify either the C++ or Lua APIs + must include a corresponding update to the appropriate API documentation. + See `docs-standards` for details. + +Other ways to help +================== +DFHack is a software project, but there's a lot more to it than programming. +If you're not comfortable programming, you can help by: + +* reporting bugs and incomplete documentation +* improving the documentation (C++ api is rife) +* finding third-party scripts to add +* writing tutorials for newbies + +All those things are crucial, and often under-represented. So if that's +your thing, go get started! diff --git a/docs/dev/Dev-intro.rst b/docs/dev/Dev-intro.rst new file mode 100644 index 0000000000..92967cf15e --- /dev/null +++ b/docs/dev/Dev-intro.rst @@ -0,0 +1,124 @@ +=========================== +DFHack development overview +=========================== + +This page provides an overview of DFHack components. If you are looking to +develop a tool for DFHack, developing a script or plugin is likely the most +straightforward choice. + +Other pages that may be relevant include: + +- `building-dfhack-index` +- `contributing` +- `documentation` +- `license` + +.. contents:: Contents + :local: + +.. _architectural-diagrams: + +Architecture diagrams +--------------------- + +These two diagrams give a very high level overview of where DFHack fits into +the DF call structure and how the pieces of DFHack itself fit together: + +.. image:: https://lh3.googleusercontent.com/d/1-2yeNMC7WHgMfZ9iQsDQ0dEbLukd_xyU + :alt: DFHack logic injection diagram + :target: https://drive.google.com/file/d/1-2yeNMC7WHgMfZ9iQsDQ0dEbLukd_xyU + :align: center + +When DF loads, it looks for a "dfhooks" library file (named appropriately per +platform, e.g. ``libdfhooks.so`` on Linux). DFHack provides this library file, +and DF calls the API functions at specific points in its initialization code +and main event loop. + +In addition, DFHack can "interpose" the virtual methods of DF classes. In +particular, it intercepts calls to the interface functions of each DF +viewscreen class to provide `overlay` functionality. + +The dfhooks API is defined in DF's open source component ``g_src``: +https://github.com/Putnam3145/Dwarf-Fortress--libgraphics--/blob/master/g_src/dfhooks.h + +.. image:: https://lh3.googleusercontent.com/d/1--JoEQbzKpVUOkRKDD9HxvuCqtom780F + :alt: DFHack tool call graph + :target: https://drive.google.com/file/d/1--JoEQbzKpVUOkRKDD9HxvuCqtom780F + :align: center + +DF memory layout is encoded in the xml files of the +`df-structures `__ repository. These +XML files are converted into C++ header files during the build process. + +The functionality of the DFHack core library is grouped by `Modules`_ that +access DF memory according to the defined structures. + +The Lua API layer makes DFHack core facilities available to Lua scripts. Both +the C++ and Lua APIs have a library of convenience functions, though only the +Lua API is `well-documented `. Notably, the entire +`UI widget library` is Lua-only, though C++ plugins can easily +access it via the plugin-Lua interop layer. + +Plugins +------- + +DFHack plugins are written in C++ and located in the ``plugins`` folder. +Currently, documentation on how to write plugins is somewhat sparse. There are +templates that you can use to get started in the :source:`plugins/examples` +folder, and the source code of existing plugins is also helpful. + +If you want to compile a plugin that you have just added, you will need to add a +call to ``DFHACK_PLUGIN`` in :source:`plugins/CMakeLists.txt`. + +Plugins have the ability to make one or more commands available to users of the +DFHack console. Examples include `3dveins` (which implements the ``3dveins`` +command) and `reveal` (which implements ``reveal``, ``unreveal``, and several +other commands). + +Plugins can also register handlers to run on every tick, and can interface with +the built-in `enable` and `disable` commands. For the full plugin API, see the +example :source:`skeleton ` plugin. + +Installed plugins live in the ``hack/plugins`` folder of a DFHack installation, +and the `load` family of commands can be used to load a recompiled plugin +without restarting DF. + +Run `plug` at the DFHack prompt for a list of all plugins included in DFHack. + +Scripts +------- + +DFHack scripts are written in Lua, with a `well-documented library `. +Referring to existing scripts as well as the API documentation is very helpful +when developing new scripts. + +Scripts included in DFHack live in a separate +:source-scripts:`scripts repository <>`. This can be found in the ``scripts`` +submodule if you have `cloned DFHack `, or the +``hack/scripts`` folder of an installed copy of DFHack. + +Core +---- + +The `DFHack core ` has a variety of low-level functions. It is +responsible for implementing the dfhooks API that DF calls, it provides a +console, and it provides an interface for plugins and scripts to interact with +DF. + +Modules +------- + +A lot of shared code to interact with DF in more complicated ways is contained +in **modules**. For example, the Units module contains functions for checking +various traits of units, changing nicknames properly, and more. Generally, code +that is useful to multiple plugins and scripts should go in the appropriate +module, if there is one. + +Most modules are also `exposed to Lua `, although some +functions (and some entire modules) are currently only available in C++. + +Remote access interface +----------------------- + +DFHack provides a remote access interface that external tools can connect to and +use to interact with DF. See `remote` for more information. diff --git a/docs/dev/Documentation.rst b/docs/dev/Documentation.rst new file mode 100644 index 0000000000..0ba61c404d --- /dev/null +++ b/docs/dev/Documentation.rst @@ -0,0 +1,607 @@ +.. _documentation: + +########################### +DFHack documentation system +########################### + + +DFHack documentation, like the file you are reading now, is created as a set of +``.rst`` files in `reStructuredText (reST) `_ +format. This is a documentation format common in the Python community. It is very +similar in concept -- and in syntax -- to Markdown, as found on GitHub and many other +places. However it is more advanced than Markdown, with more features available when +compiled to HTML, such as automatic tables of contents, cross-linking, special +external links (forum, wiki, etc) and more. The documentation is compiled by a +Python tool named `Sphinx `_. + +The DFHack build process will compile and install the documentation so it can be +displayed in-game by the `help` and `ls` commands (and any other command or GUI that +displays help text), but documentation compilation is disabled by default due to the +additional Python and Sphinx requirements. If you already have a version of the docs +installed (say from a downloaded release binary), then you only need to build the docs +if you're changing them and want to see the changes reflected in your game. + +You can also build the docs if you just want a local HTML- or text-rendered copy, though +you can always read the `online version `_ too. +The active development version of the documentation is tagged with ``latest`` and +is available `here `_ + +Note that even if you do want a local copy, it is certainly not necessary to +compile the documentation in order to read it. Like Markdown, reST documents are +designed to be just as readable in a plain-text editor as they are in HTML format. +The main thing you lose in plain text format is hyperlinking. + +.. contents:: Contents + :local: + +Concepts and general guidance +============================= + +The source ``.rst`` files are compiled to HTML for viewing in a browser and to text +format for viewing in-game. For in-game help, the help text is read from its installed +location in ``hack/docs`` under the DF directory. + +When writing documentation, remember that everything should be documented! If it's not +clear *where* a particular thing should be documented, ask on Discord or in the DFHack +thread on Bay12 -- you'll not only be getting help, you'll also be providing valuable +feedback that makes it easier for future contributors to find documentation on how to +write the documentation! + +Try to keep lines within 80-100 characters so it's readable in plain text in the +terminal - Sphinx (our documentation system) will make sure paragraphs flow. + +Short descriptions +------------------ + +Each command that a user can run -- as well as every plugin -- needs to have a +short (~54 character) descriptive string associated with it. This description text is: + +- used in-game by the `ls` command and DFHack UI screens that list commands +- used in the generated index entries in the HTML docs + +Tags +---- + +To make it easier for players to find related commands, all plugins and commands are marked +with relevant tags. These are used to compile indices and generate cross-links between the +commands, both in the HTML documents and in-game. See the list of available `tag-list` and +think about which categories your new tool belongs in. + +.. _docs-links: + +Links +----- + +If it would be helpful to mention another DFHack command, don't just type the +name - add a hyperlink! Specify the link target in backticks, and it will be +replaced with the corresponding title and linked: e.g. ```autolabor``` +=> `autolabor`. Scripts and plugins have link targets that match their names +created for you automatically. + +If you want to link to a heading in your own page, you can specify it like this:: + + `Heading text exactly as written`_ + +Note that the DFHack documentation is configured so that single backticks (with +no prefix or suffix) produce links to internal link targets, such as the +``autolabor`` target shown above. This is different from the reStructuredText +default behavior of rendering such text in italics (as a reference to a title). +For alternative link behaviors, see: + +- `The reStructuredText documentation on roles `__ +- `The reStructuredText documentation on external links `__ +- `The Sphinx documentation on roles `__ + - ``:doc:`` is useful for linking to another document outside of DFHack. + +.. _docs-standards: + +Documentation standards +======================= + +.. highlight:: rst + +Whether you're adding new code or just fixing old documentation (and there's plenty), +there are a few important standards for completeness and consistent style. Treat +this section as a guide rather than iron law, match the surrounding text, and you'll +be fine. + +Where do I add the help text? +----------------------------- + +For scripts and plugins that are distributed as part of DFHack, documentation files +should be added to the :source-scripts:`scripts/docs ` and :source:`docs/plugins` directories, +respectively, in a file named after the script or plugin. For example, a script named +``gui/foobar.lua`` (which provides the ``gui/foobar`` command) should be documented +in a file named ``docs/gui/foobar.rst`` in the scripts repo. Similarly, a plugin named +``foobaz`` should be documented in a file named ``docs/plugins/foobaz.rst`` in the dfhack repo. +For plugins, all commands provided by that plugin should be documented in that same file. + +Short descriptions (the ~54 character short help) for scripts and plugins are taken from +the ``summary`` attribute of the ``dfhack-tool`` directive that each tool help document must +have (see the `Header format`_ section below). Please make this brief but descriptive! + +Short descriptions for commands provided by plugins are taken from the ``description`` +parameter passed to the ``PluginCommand`` constructor used when the command is registered +in the plugin source file. + +Header format +------------- + +The docs **must** begin with a heading which exactly matches the script or plugin name, underlined +with ``=====`` to the same length. This must be followed by a ``.. dfhack-tool:`` directive with +at least the following parameters: + +* ``:summary:`` - a short, single-sentence description of the tool +* ``:tags:`` - a space-separated list of `tags ` that apply to the tool + +By default, ``dfhack-tool`` generates both a description of a tool and a command +with the same name. For tools (specifically plugins) that do not provide exactly +1 command with the same name as the tool, pass the ``:no-command:`` parameter (with +no content after it) to prevent the command block from being generated. + +For tools that provide multiple commands, or a command by the same name but with +significantly different functionality (e.g. a plugin that can be both enabled +and invoked as a command for different results), use the ``.. dfhack-command:`` +directive for each command. This takes only a ``:summary:`` argument, with the +same meaning as above. + +For example, documentation for the ``build-now`` script might look like:: + + build-now + ========= + + .. dfhack-tool:: + :summary: Instantly completes unsuspended building construction jobs. + :tags: fort armok buildings + + By default, all buildings on the map are completed, but the area of effect is configurable. + +And documentation for the ``autodump`` plugin might look like:: + + autodump + ======== + + .. dfhack-tool:: + :summary: Automatically set items in a stockpile to be dumped. + :tags: fort armok fps productivity items stockpiles + :no-command: + + .. dfhack-command:: autodump + :summary: Teleports items marked for dumping to the cursor position. + + .. dfhack-command:: autodump-destroy-here + :summary: Destroy items marked for dumping under the cursor. + + .. dfhack-command:: autodump-destroy-item + :summary: Destroys the selected item. + + When `enabled `, this plugin adds an option to the :kbd:`q` menu for + stockpiles. + + When invoked as a command, it can instantly move all unforbidden items marked + for dumping to the tile under the cursor. + +Usage help +---------- + +The first section after the header and introductory text should be the usage section. You can +choose between two formats, based on whatever is cleaner or clearer for your syntax. The first +option is to show usage formats together, with an explanation following the block:: + + Usage + ----- + + :: + + build-now [] + build-now here [] + build-now [ []] [] + + Where the optional ```` pair can be used to specify the + coordinate bounds within which ``build-now`` will operate. If + they are not specified, ``build-now`` will scan the entire map. + If only one ```` is specified, only the building at that + coordinate is built. + + The ```` parameters can either be an ``,,`` triple + (e.g. ``35,12,150``) or the string ``here``, which means the + position of the active game cursor. + +The second option is to arrange the usage options in a list, with the full command +and arguments in monospaced font. Then indent the next line and describe the effect:: + + Usage + ----- + + ``build-now []`` + Scan the entire map and build all unsuspended constructions + and buildings. + ``build-now here []`` + Build the unsuspended construction or building under the + cursor. + ``build-now [ []] []`` + Build all unsuspended constructions within the specified + coordinate box. + + The ```` parameters are specified as... + +Note that in both options, the entire commandline syntax is written, including the command itself. +Literal text is written as-is (e.g. the word ``here`` in the above example), and text that +describes the kind of parameter that is being passed (e.g. ``pos`` or ``options``) is enclosed in +angle brackets (``<`` and ``>``). Optional elements are enclosed in square brackets (``[`` and ``]``). +If the command takes an arbitrary number of elements, use ``...``, for example:: + + prioritize [] [ ...] + quickfort [,...] [,...] [] + +Examples +-------- + +If the only way to run the command is to type the command itself, then this section is not necessary. +Otherwise, please consider adding a section that shows some real, practical usage examples. For +many users, this will be the **only** section they will read. It is so important that it is a good +idea to include the ``Examples`` section **before** you describe any extended options your command +might take. Write examples for what you expect the popular use cases will be. Also be sure to write +examples showing specific, practical values being used for any parameter that takes a value or has +tricky formatting. + +Examples should go in their own subheading. The examples themselves should be organized as in +option 2 for Usage above. Here is an example ``Examples`` section:: + + Examples + -------- + + ``build-now`` + Completes all unsuspended construction jobs on the map. + ``build-now 37,20,154 here`` + Builds the unsuspended, unconstructed buildings in the box + bounded by the coordinate x=37,y=20,z=154 and the cursor. + +Options +------- + +The options header should follow the examples, with each option in the same format as the +examples:: + + Options + ------- + + ``-h``, ``--help`` + Show help text. + ``-l``, ``--quality `` + Set the quality of the architecture for built architected + buildings. + ``-q``, ``--quiet`` + Suppress informational output (error messages are still + printed). + +Note that for parameters that have both short and long forms, any values that those options +take only need to be specified once (e.g. ````). + +External scripts and plugins +============================ + +Scripts and plugins distributed separately from DFHack's release packages don't have the +opportunity to add their documentation to the rendered HTML or text output. However, these +scripts and plugins can use a different mechanism to at least make their help text available +in-game. + +Note that since help text for external scripts and plugins is not rendered by Sphinx, +it should be written in plain text. Any reStructuredText markup will not be processed and, +if present, will be shown verbatim to the player (which is probably not what you want). + +For external scripts, the short description comes from a comment on the first line +(the comment marker and extra whitespace is stripped): + +.. code-block:: lua + + -- A short description of my cool script. + +The main help text for an external script needs to appear between two markers -- ``[====[`` +and ``]====]``. The documentation standards above still apply to external tools, but there is +no need to include backticks for links or monospaced fonts. Here is an example for an +entire script header:: + + -- Inventory management for adventurers. + -- [====[ + gui/adv-inventory + ================= + + Tags: adventure | items + + Allows you to quickly move items between containers. This + includes yourself and any followers you have. + + Usage + ----- + + gui/adv-inventory [] + + Examples + -------- + + gui/adv-inventory + Opens the GUI with nothing preselected + + gui/adv-inventory take-all + Opens the GUI with all container items already selected and + ready to move into the adventurer's inventory. + + Options + ------- + + take-all + Starts the GUI with container items pre-selected + + give-all + Starts the GUI with your own items pre-selected + ]====] + +For external plugins, help text for provided commands can be passed as the ``usage`` +parameter when registering the commands with the ``PluginCommand`` constructor. There +is currently no way for associating help text with the plugin itself, so any +information about what the plugin does when enabled should be combined into the command +help. + +Required dependencies +===================== + +.. highlight:: shell + +In order to build the documentation, you must have Python with Sphinx +version |sphinx_min_version| or later and Python 3. + +When installing Sphinx from OS package managers, be aware that there is +another program called "Sphinx", completely unrelated to documentation management. +Be sure you are installing the right Sphinx; it may be called ``python-sphinx``, +for example. To avoid doubt, ``pip`` can be used instead as detailed below. + +Once you have installed Sphinx, ``sphinx-build --version`` should report the +version of Sphinx that you have installed. If this works, CMake should also be +able to find Sphinx. + +For more detailed platform-specific instructions, see the sections below: + +.. contents:: + :local: + :backlinks: none + +Linux +----- +Most Linux distributions will include Python by default. If not, start by +installing Python 3. On Debian-based distros:: + + sudo apt install python3 + +Check your package manager to see if Sphinx |sphinx_min_version| or later is +available. On Debian-based distros, this package is named ``python3-sphinx``. +If this package is new enough, you can install it directly. If not, or if you +want to use a newer Sphinx version (which may result in faster builds), you +can install Sphinx through the ``pip`` package manager instead. On Debian-based +distros, you can install pip with:: + + sudo apt install python3-pip + +Once pip is available, you can then install Sphinx with:: + + pip3 install sphinx + +If you run this as an unprivileged user, it may install a local copy of Sphinx +for your user only. The ``sphinx-build`` executable will typically end up in +``~/.local/bin/`` in this case. Alternatively, you can install Sphinx +system-wide by running pip with ``sudo``. In any case, you will need the folder +containing ``sphinx-build`` to be in your ``$PATH``. + +macOS +----- +macOS has Python 2.7 installed by default, but it does not have the pip package manager. + +You can install Homebrew's Python 3, which includes pip, and then install the +latest Sphinx using pip:: + + brew install python3 + pip3 install sphinx + +Windows +------- +Python for Windows can be downloaded `from python.org `_. +The latest version of Python 3 includes pip already. + +You can also install Python and pip through the Chocolatey package manager. +After installing Chocolatey as outlined in the `Windows compilation instructions `, +run the following command from an elevated (admin) command prompt (e.g. ``cmd.exe``):: + + choco install python pip -y + +Once you have pip available, you can install Sphinx with the following command:: + + pip install sphinx + +Note that this may require opening a new (admin) command prompt if you just +installed pip from the same command prompt. + +.. _docs-build: + +Building the documentation +========================== + +Once the required dependencies are installed, there are multiple ways to run +Sphinx to build the docs: + +Using CMake +----------- + +See our page on `build options `. + +Using the documentation build script +------------------------------------ + +You can also build the documentation without running CMake - this is faster if +you only want to rebuild the documentation regardless of any code changes. + +The recommended approach is the ``docs/build.py`` script. This is the same +script that CMake uses internally, which wraps Sphinx with a few additional +options to handle common cases and can build multiple documentation formats with +a single invocation. + +Examples: + +* ``docs/build.py`` + Build just the HTML docs + +* ``docs/build.py html text`` + Build both the HTML and text docs + +* ``docs/build.py --clean`` + Build HTML and force a clean build (all source files are re-read) + +* ``docs/build.py --help`` + Display a full list of available options + +The resulting documentation will be stored in ``docs/html`` and/or ``docs/text`` +(or generally, a subfolder of ``docs/`` named after the requested output format(s)). + +Building a PDF version +---------------------- + +ReadTheDocs automatically builds a PDF version of the documentation (available +under the "Downloads" section when clicking on the release selector). If you +want to build a PDF version locally, you will need the ``pdflatex`` command, which is part +of a TeX distribution. The following command will then build a PDF, located in +``docs/pdf/latex/DFHack.pdf``, with default options:: + + docs/build.py pdf + +Running Sphinx manually +----------------------- + +If ``docs/build.py`` does not support what you need, you can also run Sphinx +manually. This is primarily useful for low-level debugging. + +For a good starting point, add the ``--debug`` argument to your call to +``docs/build.py``. This will cause the script to print out the Sphinx command(s) +that it is running. + +Some examples: + +* ``sphinx-build . docs/html`` + Build the HTML docs (equivalent to ``docs/build.py``) + +* ``sphinx-build -b text . docs/text`` + Build the plain text docs (equivalent to ``docs/build.py text``) + +* ``sphinx-build -M latexpdf . docs/pdf`` + Build the PDF docs + +Sphinx has many options to enable clean builds, parallel builds, logging, and +more - run ``sphinx-build --help`` for details. If you specify a different +output path, be warned that Sphinx may overwrite existing files in the output +folder. Also be aware that when running ``sphinx-build`` directly, the +``docs/html`` folder may be polluted with intermediate build files that normally +get written in the cmake ``build`` directory. + +Troubleshooting +=============== + +Sphinx errors are typically printed by Sphinx, so ensure that you are not silencing Sphinx output. + +When built with ``docs/build.py`` or CMake, errors are also logged to +``build/docs//sphinx-warnings.txt`` (for instance, if you are building +the HTML docs, ``build/docs/html/sphinx-warnings.txt``). + + +"undefined label" +----------------- + +Typical causes: + +* You have used single backticks for an inline code snippet, where double backticks should be used instead (see `docs-links`):: + + `this is an invalid inline code snippet (actually a link)` + ``this is a valid inline code snippet`` + +* You are attempting to link to a section/label, but either it does not have a label defined or you have spelled it incorrectly:: + + .. my-label: + + This is where the link should go to. + + ... + + This is `a valid link to the earlier label `. So is `my-label`. + +"toctree contains reference to document that doesn't have a title" +------------------------------------------------------------------ + +Due to the nature of our autogenerated documentation, this can sometimes occur +when switching between branches that have different autogenerated files, and can +result in autogenerated documentation (e.g. for individual tools) being missing +from the table of contents, or links failing to generate. + +The quickest resolution is a clean docs build:: + + docs/build.py --clean + +.. _build-changelog: + +Building the changelogs +======================= +If you have Python installed, you can build just the changelogs without building +the rest of the documentation by running the ``docs/gen_changelog.py`` script. +This script provides additional options, including one to build individual +changelogs for all DFHack versions - run ``python docs/gen_changelog.py --help`` +for details. + +Changelog entries are obtained from ``changelog.txt`` files in multiple repos. +This allows changes to be listed in the same repo where they were made. These +changelogs are combined as part of the changelog build process: + +* ``docs/changelog.txt`` for changes in the main ``dfhack`` repo +* ``scripts/changelog.txt`` for changes made to scripts in the ``scripts`` repo +* ``library/xml/changelog.txt`` for changes made in the ``df-structures`` repo +* ``plugins/stonesense/changelog.txt`` for changes made in the ``stonesense`` + repo + +Building the changelogs generates two files: ``docs/changelogs/news.rst`` and +``docs/changelogs/news-dev.rst``. These correspond to `changelog` and +`dev-changelog` and contain changes organized by stable and development DFHack +releases, respectively. For example, an entry listed under "0.44.05-alpha1" in +changelog.txt will be listed under that version in the development changelog as +well, but under "0.44.05-r1" in the stable changelog (assuming that is the +closest stable release after 0.44.05-alpha1). An entry listed under a stable +release like "0.44.05-r1" in changelog.txt will be listed under that release in +both the stable changelog and the development changelog. + +Changelog syntax +---------------- + +.. include:: /docs/changelog.txt + :start-after: ===syntax-reference-start + :end-before: ===syntax-reference-end + +.. _docs-ci: + +GitHub Actions +============== + +Documentation is built automatically with GitHub Actions (a GitHub-provided +continuous integration service) for all pull requests and commits in the +"dfhack" and "scripts" repositories. These builds run with strict settings, i.e. +warnings are treated as errors. If a build fails, you will see a red "x" next to +the relevant commit or pull request. You can view detailed output from Sphinx in +a few ways: + +* Click on the red "x" (or green checkmark), then click "Details" next to + the "Build / docs" entry +* For pull requests only: navigate to the "Checks" tab, then click on "Build" in + the sidebar to expand it, then "docs" under it + +Sphinx output will be visible under the step named "Build docs". If a different +step failed, or you aren't sure how to interpret the output, leave a comment +on the pull request (or commit). + +You can also download the "docs" artifact from the summary page (typically +accessible by clicking "Build") if the build succeeded. This is a way to +visually inspect what the documentation looks like when built without installing +Sphinx locally, although we recommend installing Sphinx if you are planning to +do any significant work on the documentation. diff --git a/docs/dev/Lua API.rst b/docs/dev/Lua API.rst new file mode 100644 index 0000000000..e8a1cd9f67 --- /dev/null +++ b/docs/dev/Lua API.rst @@ -0,0 +1,7775 @@ +.. highlight:: lua + +.. _lua-api: + +######################## +DFHack Lua API Reference +######################## + +DFHack has extensive support for +the Lua_ scripting language, providing access to: + +.. _Lua: https://www.lua.org + +1. Raw data structures used by the game. +2. Many C++ functions for high-level access to these + structures, and interaction with dfhack itself. +3. Some functions exported by C++ plugins. + +Lua code can be used both for writing scripts, which +are treated by DFHack command line prompt almost as +native C++ commands, and invoked by plugins written in C++. + +This document describes native API available to Lua in detail. +It does not describe all of the utility functions +implemented by Lua files located in :file:`hack/lua/*` +(:file:`library/lua/*` in the git repo). + +.. admonition:: Is this the DF or DFHack Lua API? + :class: warning + + This document describes the Lua API provided by DFHack, not + the Lua API provided by Dwarf Fortress. For information about DF's Lua API, see + :wiki:`Lua scripting` + on the Dwarf Fortress Wiki. + +.. contents:: Contents + :local: + :depth: 2 + +.. _lua-df: + +========================= +DF data structure wrapper +========================= + +.. contents:: + :local: + +Data structures of the game are defined in XML files located in :file:`library/xml` +(and `online `_, and automatically exported +to lua code as a tree of objects and functions under the ``df`` global, which +also broadly maps to the ``df`` namespace in the headers generated for C++. + +.. warning:: + + The wrapper provides almost raw access to the memory of the game, so + mistakes in manipulating objects are as likely to crash the game as + equivalent plain C++ code would be - e.g., null pointer access is safely + detected, but dangling pointers aren't. + +Objects managed by the wrapper can be broadly classified into the following groups: + +1. Typed object pointers (references). + + References represent objects in DF memory with a known type. + + In addition to fields and methods defined by the wrapped type, + every reference has some built-in properties and methods. + +2. Untyped pointers + + Represented as lightuserdata. + + In assignment to a pointer NULL can be represented either as + ``nil``, or a NULL lightuserdata; reading a NULL pointer field + returns ``nil``. + +3. Named types + + Objects in the ``df`` tree that represent identity of struct, class, + enum and bitfield types. They host nested named types, static + methods, builtin properties & methods, and, for enums and bitfields, + the bi-directional mapping between key names and values. + +4. The ``global`` object + + ``df.global`` corresponds to the ``df::global`` namespace, and + behaves as a mix between a named type and a reference, containing + both nested types and fields corresponding to global symbols. + +In addition to the ``global`` object and top-level types the ``df`` +global also contains a few global builtin utility functions. + +Typed object references +======================= + +The underlying primitive lua object is userdata with a metatable. +Every structured field access produces a new userdata instance. + +All typed objects have the following built-in features: + +* ``ref1 == ref2``, ``tostring(ref)`` + + References implement equality by type & pointer value, and string conversion. + +* ``pairs(ref)`` + + Returns an iterator for the sequence of actual C++ field names + and values. Fields are enumerated in memory order. Methods and + lua wrapper properties are not included in the iteration. + + .. warning:: + a few of the data structures (like ui_look_list) + contain unions with pointers to different types with vtables. + Using pairs on such structs is an almost sure way to crash with + an access violation. + +* ``ref._kind`` + + Returns one of: ``primitive``, ``struct``, ``container``, + or ``bitfield``, as appropriate for the referenced object. + +* ``ref._type`` + + Returns the named type object or a string that represents + the referenced object type. + +* ``ref:sizeof()`` + + Returns *size, address* + +* ``ref:new()`` + + Allocates a new instance of the same type, and copies data + from the current object. + +* ``ref:delete()`` + + Destroys the object with the C++ ``delete`` operator. If the destructor is not + available, returns *false*. (This typically only occurs when trying to delete + an instance of a DF class with virtual methods whose vtable address has not + been found; it is impossible for ``delete()`` to determine the validity of + ``ref``.) + + .. warning:: + ``ref`` **must** be an object allocated with ``new``, like in C++. Calling + ``obj.field:delete()`` where ``obj`` was allocated with ``new`` will not + work. After ``delete()`` returns, ``ref`` remains as a dangling pointer, + like a raw C++ pointer would. Any accesses to ``ref`` after ``ref:delete()`` + has been called are undefined behavior. + +* ``ref:assign(object)`` + + Assigns data from object to ref. Object must either be another + ref of a compatible type, or a lua table; in the latter case + special recursive assignment rules are applied. + +* ``ref:_displace(index[,step])`` + + Returns a new reference with the pointer adjusted by index*step. + Step defaults to the natural object size. + +Primitive references +-------------------- + +References of the *_kind* ``'primitive'`` are used for objects +that don't fit any of the other reference types. Such +references can only appear as a value of a pointer field, +or as a result of calling the ``_field()`` method. + +They behave as structs with a ``value`` field of the right type. If the +object's XML definition has a ``ref-target`` attribute, they will also have +a read-only ``ref_target`` field set to the corresponding type object. + +To make working with numeric buffers easier, they also allow +numeric indices. Note that other than excluding negative values +no bound checking is performed, since buffer length is not available. +Index 0 is equivalent to the ``value`` field. + + +Struct references +----------------- + +Struct references are used for class and struct objects. + +They implement the following features: + +* ``ref.field``, ``ref.field = value`` + + Valid fields of the structure may be accessed by subscript. + + Primitive typed fields, i.e., numbers & strings, are converted + to/from matching lua values. The value of a pointer is a reference + to the target, or ``nil``/NULL. Complex types are represented by + a reference to the field within the structure; unless recursive + lua table assignment is used, such fields can only be read. + + .. note:: + In case of inheritance, *superclass* fields have precedence + over the subclass, but fields shadowed in this way can still + be accessed as ``ref['subclasstype.field']``. + + This shadowing order is necessary because vtable-based classes + are automatically exposed in their exact type, and the reverse + rule would make access to superclass fields unreliable. + +* ``ref:_field(field)`` + + Returns a reference to a valid field. That is, unlike regular + subscript, it returns a reference to the field within the structure + even for primitive typed fields and pointers. Fails with an error + if the field is not found. + +* ``ref:vmethod(args...)`` + + Named virtual methods are also exposed, subject to the same + shadowing rules. + +* ``pairs(ref)`` + + Enumerates all real fields (but not methods) in memory + order, which is the same as declaration order. + +Container references +-------------------- + +Containers represent vectors and arrays, possibly resizable. + +A container field can associate an enum to the container +reference, which allows accessing elements using string keys +instead of numerical indices. + +Note that two-dimensional arrays in C++ (ie pointers to pointers) +are exposed to lua as one-dimensional. The best way to handle this +is probably ``array[x].value:_displace(y)``. + +Implemented features: + +* ``ref._enum`` + + If the container has an associated enum, returns the matching + named type object. + +* ``#ref`` + + Returns the *length* of the container. + +* ``ref[index]`` + + Accesses the container element, using either a *0-based* numerical + index, or, if an enum is associated, a valid enum key string. + + Accessing an invalid index is an error, but some container types + may return a default value, or auto-resize instead for convenience. + Currently this relaxed mode is implemented by df-flagarray aka BitArray. + +* ``ref:_field(index)`` + + Like with structs, returns a pointer to the array element, if possible. + Flag and bit arrays cannot return such pointer, so it fails with an error. + +* ``pairs(ref)``, ``ipairs(ref)`` + + If the container has no associated enum, both behave identically, + iterating over numerical indices in order. Otherwise, ipairs still + uses numbers, while pairs tries to substitute enum keys whenever + possible. + +* ``ref:resize(new_size)`` + + Resizes the container if supported, or fails with an error. + +* ``ref:insert(index,item)`` + + Inserts a new item at the specified index. To add at the end, + use ``#ref``, or just ``'#'`` as index. + +* ``ref:erase(index)`` + + Removes the element at the given valid index. + +Bitfield references +------------------- + +Bitfields behave like special fixed-size containers. +Consider them to be something in between structs and +fixed-size vectors. + +The ``_enum`` property points to the bitfield type. +Numerical indices correspond to the shift value, +and if a subfield occupies multiple bits, the +``ipairs`` order would have a gap. + +Additionally, bitfields have a ``whole`` property, +which returns the value of the bitfield as an +integer. + +Since currently there is no API to allocate a bitfield +object fully in GC-managed lua heap, consider using the +lua table assignment feature outlined below in order to +pass bitfield values to dfhack API functions that need +them, e.g., ``matinfo:matches{metal=true}``. + + +Named types +=========== + +Named types are exposed in the ``df`` tree with names identical +to the C++ version, except for the ``::`` vs ``.`` difference. + +All types and the global object have the following features: + +* ``type._kind`` + + Evaluates to one of ``struct-type``, ``class-type``, ``enum-type``, + ``bitfield-type`` or ``global``. + +* ``type._identity`` + + Contains a lightuserdata pointing to the underlying + ``DFHack::type_identity`` object. + +All compound types (structs, classes, unions, and the global object) support: + +* ``type._union`` + + ``true`` if the type represents a union, otherwise ``nil``. + +* ``type._fields`` + + Contains a table mapping field names to descriptions of the type's fields, + including data members and functions. Iterating with ``pairs()`` returns data + fields in the order they are defined in the type. Functions and globals may + appear in an arbitrary order. + + Each entry contains the following fields: + + * ``name``: the name of the field (matches the ``_fields`` table key) + * ``offset``: for data members, the position of the field relative to the start of the type, in bytes + * ``count``: for arrays, the number of elements + * ``mode``: implementation detail. See ``struct_field_info::Mode`` in ``DataDefs.h``. + + Each entry may also contain the following fields, depending on its type: + + * ``type_name``: present for most fields; a string representation of the field's type + * ``type``: the type object matching the field's type; present if such an object exists + (e.g., present for DF types, absent for primitive types) + * ``type_identity``: present for most fields; a lightuserdata pointing to the field's underlying ``DFHack::type_identity`` object + * ``index_enum``, ``ref_target``: the type object corresponding to the field's similarly-named XML attribute, if present + * ``union_tag_field``, ``union_tag_attr``, ``original_name``: the string value of the field's similarly-named XML attribute, if present + +Types excluding the global object also support: + +* ``type:sizeof()`` + + Returns the size of an object of the type. + +* ``type:new()`` + + Creates a new instance of an object of the type. + +* ``type:is_instance(object)`` + + Returns true if object is same or subclass type, or a reference + to an object of same or subclass type. It is permissible to pass + ``nil``, NULL or non-wrapper value as object; in this case the + method returns ``nil``. + +Enum types support the following: + +* ``type.next_item(index)`` + + Returns the next valid numeric value of the enum. It returns the + first enum value if ``index`` is greater than or equal to the max + enum value. + +* ``type.attrs`` + + A mapping of enum keys (usually integers) and values (usually strings) to + their attributes. e.g ``df.goal_type.attrs.STAY_ALIVE`` returns + ``{ short_name: "Stay Alive", achieved_short_name: "Stayed Alive" } }`` + +* ``type._attr_entry_type`` + + Returns the named ``struct-type`` type representing the table returned + by ``type.attrs``. + +In addition to this, enum and bitfield types contain a +bi-directional mapping between key strings and values, and +also map ``_first_item`` and ``_last_item`` to the min and +max values. + +Struct and class types with an instance-vector attribute in the XML also support: + +* ``type.find(key)`` + + Returns an object from the instance vector that matches the key, where the + field is determined by the 'key-field' specified in the XML. + +* ``type.get_vector()`` + + Returns the instance vector e.g ``df.item.get_vector() == df.global.world.items.all`` + +Global functions +================ + +The ``df`` table itself contains the following functions and values: + +* ``NULL``, ``df.NULL`` + + Contains the NULL lightuserdata. + +* ``df.isnull(obj)`` + + Evaluates to true if obj is nil or NULL; false otherwise. + +* ``df.isvalid(obj[,allow_null])`` + + For supported objects returns one of ``type``, ``voidptr``, ``ref``. + + If *allow_null* is true, and obj is nil or NULL, returns ``null``. + + Otherwise returns *nil*. + +* ``df.sizeof(obj)`` + + For types and refs identical to ``obj:sizeof()``. + For lightuserdata returns *nil, address* + +* ``df.new(obj)``, ``df.delete(obj)``, ``df.assign(obj, obj2)`` + + Equivalent to using the matching methods of obj. + +* ``df._displace(obj,index[,step])`` + + For refs equivalent to the method, but also works with + lightuserdata (step is mandatory then). + +* ``df.is_instance(type,obj)`` + + Equivalent to the method, but also allows a reference as proxy for its type. + +* ``df.new(ptype[,count])`` + + Allocate a new instance, or an array of built-in types. + The ``ptype`` argument is a string from the following list: + ``string``, ``int8_t``, ``uint8_t``, ``int16_t``, ``uint16_t``, + ``int32_t``, ``uint32_t``, ``int64_t``, ``uint64_t``, ``bool``, + ``float``, ``double``. All of these except ``string`` can be + used with the count argument to allocate an array. + +* ``df.reinterpret_cast(type,ptr)`` + + Converts ptr to a ref of specified type. The type may be anything + acceptable to ``df.is_instance``. Ptr may be *nil*, a ref, + a lightuserdata, or a number. + + Returns *nil* if NULL, or a ref. + +.. _lua-api-table-assignment: + +Recursive table assignment +========================== + +Recursive assignment is invoked when a lua table is assigned +to a C++ object or field, i.e., one of: + +* ``ref:assign{...}`` +* ``ref.field = {...}`` + +The general mode of operation is that all fields of the table +are assigned to the fields of the target structure, roughly +emulating the following code:: + + function rec_assign(ref,table) + for key,value in pairs(table) do + ref[key] = value + end + end + +Since assigning a table to a field using = invokes the same +process, it is recursive. + +There are however some variations to this process depending +on the type of the field being assigned to: + +1. If the table contains an ``assign`` field, it is + applied first, using the ``ref:assign(value)`` method. + It is never assigned as a usual field. + +2. When a table is assigned to a non-NULL pointer field + using the ``ref.field = {...}`` syntax, it is applied + to the target of the pointer instead. + + If the pointer is NULL, the table is checked for a ``new`` field: + + a. If it is *nil* or *false*, assignment fails with an error. + + b. If it is *true*, the pointer is initialized with a newly + allocated object of the declared target type of the pointer. + + c. Otherwise, ``table.new`` must be a named type, or an + object of a type compatible with the pointer. The pointer + is initialized with the result of calling ``table.new:new()``. + + After this auto-vivification process, assignment proceeds + as if the pointer wasn't NULL. + + Obviously, the ``new`` field inside the table is always skipped + during the actual per-field assignment processing. + +3. If the target of the assignment is a container, a separate + rule set is used: + + a. If the table contains neither ``assign`` nor ``resize`` + fields, it is interpreted as an ordinary *1-based* lua + array. The container is resized to the #-size of the + table, and elements are assigned in numeric order:: + + ref:resize(#table); + for i=1,#table do ref[i-1] = table[i] end + + b. Otherwise, ``resize`` must be *true*, *false*, or + an explicit number. If it is not false, the container + is resized. After that the usual struct-like 'pairs' + assignment is performed. + + In case ``resize`` is *true*, the size is computed + by scanning the table for the largest numeric key. + + This means that in order to reassign only one element of + a container using this system, it is necessary to use:: + + { resize=false, [idx]=value } + +Since ``nil`` inside a table is indistinguishable from missing key, +it is necessary to use ``df.NULL`` as a null pointer value. + +This system is intended as a way to define a nested object +tree using pure lua data structures, and then materialize it in +C++ memory in one go. Note that if pointer auto-vivification +is used, an error in the middle of the recursive walk would +not destroy any objects allocated in this way, so the user +should be prepared to catch the error and do the necessary +cleanup. + +========== +DFHack API +========== + +.. contents:: + :local: + +DFHack utility functions are placed in the ``dfhack`` global tree. + +Native utilities +================ + +Input & Output +-------------- + +* ``dfhack.print(args...)`` + + Output tab-separated args as standard lua print would do, + but without a newline. + +* ``print(args...)``, ``dfhack.println(args...)`` + + A replacement of the standard library print function that + works with DFHack output infrastructure. + +* ``dfhack.printerr(args...)`` + + Same as println; intended for errors. Uses red color and logs to stderr.log. + +* ``dfhack.color([color])`` + + Sets the current output color. If color is *nil* or *-1*, resets to default. + Returns the previous color value. + +* ``dfhack.is_interactive()`` + + Checks if the thread can access the interactive console and returns *true* or *false*. + +* ``dfhack.lineedit([prompt[,history_filename]])`` + + If the thread owns the interactive console, shows a prompt + and returns the entered string. Otherwise returns *nil, error*. + + Depending on the context, this function may actually yield the + running coroutine and let the C++ code release the core suspend + lock. Using an explicit ``dfhack.with_suspend`` will prevent + this, forcing the function to block on input with lock held. + +* ``dfhack.getCommandHistory(history_id, history_filename)`` + + Returns the list of strings in the specified history. Intended to be used by + GUI scripts that don't have access to a console and so can't use + ``dfhack.lineedit``. The ``history_id`` parameter is some unique string that + the script uses to identify its command history, such as the script's name. If + this is the first time the history with the given ``history_id`` is being + accessed, it is initialized from the given file. + +* ``dfhack.addCommandToHistory(history_id, history_filename, command)`` + + Adds a command to the specified history and saves the updated history to the + specified file. + +* ``dfhack.interpreter([prompt[,history_filename[,env]]])`` + + Starts an interactive lua interpreter, using the specified prompt + string, global environment and command-line history file. + + If the interactive console is not accessible, returns *nil, error*. + + +Exception handling +------------------ + +* ``dfhack.error(msg[,level[,verbose]])`` + + Throws a dfhack exception object with location and stack trace. + The verbose parameter controls whether the trace is printed by default. + +* ``qerror(msg[,level])`` + + Calls ``dfhack.error()`` with ``verbose`` being *false*. Intended to + be used for user-caused errors in scripts, where stack traces are not + desirable. + +* ``dfhack.pcall(f[,args...])`` + + Invokes f via xpcall, using an error function that attaches + a stack trace to the error. The same function is used by SafeCall + in C++, and dfhack.safecall. + +* ``safecall(f[,args...])``, ``dfhack.safecall(f[,args...])`` + + Just like pcall, but also prints the error using printerr before + returning. Intended as a convenience function. + +* ``dfhack.saferesume(coroutine[,args...])`` + + Compares to coroutine.resume like dfhack.safecall vs pcall. + +* ``dfhack.exception`` + + Metatable of error objects used by dfhack. The objects have the + following properties: + + ``err.where`` + The location prefix string, or *nil*. + ``err.message`` + The base message string. + ``err.stacktrace`` + The stack trace string, or *nil*. + ``err.cause`` + A different exception object, or *nil*. + ``err.thread`` + The coroutine that has thrown the exception. + ``err.verbose`` + Boolean, or *nil*; specifies if where and stacktrace should be printed. + ``tostring(err)``, or ``err:tostring([verbose])`` + Converts the exception to string. + +* ``dfhack.exception.verbose`` + + The default value of the ``verbose`` argument of ``err:tostring()``. + + +Miscellaneous +------------- + +* ``dfhack.VERSION`` + + DFHack version string constant. + +* ``dfhack.curry(func,args...)``, or ``curry(func,args...)`` + + Returns a closure that invokes the function with args combined + both from the curry call and the closure call itself. I.e., + ``curry(func,a,b)(c,d)`` equals ``func(a,b,c,d)``. + + +Locking and finalization +------------------------ + +* ``dfhack.with_suspend(f[,args...])`` + + Calls ``f`` with arguments after grabbing the DF core suspend lock. + Suspending is necessary for accessing a consistent state of DF memory. + + Returned values and errors are propagated through after releasing + the lock. It is safe to nest suspends. + + Every thread is allowed only one suspend per DF frame, so it is best + to group operations together in one big critical section. A plugin + can choose to run all lua code inside a C++-side suspend lock. + +* ``dfhack.call_with_finalizer(num_cleanup_args,always,cleanup_fn[,cleanup_args...],fn[,args...])`` + + Invokes ``fn`` with ``args``, and after it returns or throws an + error calls ``cleanup_fn`` with ``cleanup_args``. Any return values from + ``fn`` are propagated, and errors are re-thrown. + + The ``num_cleanup_args`` integer specifies the number of ``cleanup_args``, + and the ``always`` boolean specifies if cleanup should be called in any case, + or only in case of an error. + +* ``dfhack.with_finalize(cleanup_fn,fn[,args...])`` + + Calls ``fn`` with arguments, then finalizes with ``cleanup_fn``. + Implemented using ``call_with_finalizer(0,true,...)``. + +* ``dfhack.with_onerror(cleanup_fn,fn[,args...])`` + + Calls ``fn`` with arguments, then finalizes with ``cleanup_fn`` on any thrown error. + Implemented using ``call_with_finalizer(0,false,...)``. + +* ``dfhack.with_temp_object(obj,fn[,args...])`` + + Calls ``fn(obj,args...)``, then finalizes with ``obj:delete()``. + +.. _persistent-api: + +Persistent configuration storage +-------------------------------- + +This api is intended for storing tool state in the world savegame directory. It +is intended for data that is world-dependent. Global state that is independent +of the loaded world should be saved into a separate file named after the tool +in the ``dfhack-config/`` directory. + +Entries are associated with the current loaded site (fortress) and are +identified by a string ``key``. The data will still be associated with a fort +if the fort is retired and then later unretired. Entries are stored as +serialized strings, but there are convenience functions for working with +arbitrary Lua tables. + +* ``dfhack.persistent.getSiteData(key[, default])`` + + Retrieves the Lua table associated with the current site and the given string + ``key``. If ``default`` is supplied, then it is returned if the key isn't + found in the current site's persistent data. + + Example usage:: + + local state = dfhack.persistent.getSiteData('my-script-name', {somedata={}}) + +* ``dfhack.persistent.getSiteDataString(key)`` + + Retrieves the underlying serialized string associated with the current site + and the given string ``key``. Returns *nil* if the key isn't found in the + current site's persistent data. Most scripts will want to use ``getSiteData`` + instead. + +* ``dfhack.persistent.saveSiteData(key, data)`` + + Persists the given ``data`` (usually a table; can be of arbitrary complexity and depth) + in the world save, associated with the current site and the given ``key``. + +* ``dfhack.persistent.saveSiteDataString(key, data_str)`` + + Persists the given string in the world save, associated with the current site + and the given ``key``. + +* ``dfhack.persistent.deleteSiteData(key)`` + + Removes the existing entry associated with the current site and the given + ``key``. Returns *true* if succeeded. + +* ``dfhack.persistent.getWorldData(key[, default])`` +* ``dfhack.persistent.getWorldDataString(key)`` +* ``dfhack.persistent.saveWorldData(key, data)`` +* ``dfhack.persistent.saveWorldDataString(key, data_str)`` +* ``dfhack.persistent.deleteWorldData(key)`` + + Same semantics as for the ``Site`` functions, but will associated the data + with the global world context. + +* ``dfhack.persistent.getUnsavedSeconds()`` + + Returns the number of seconds since last save or load of a save. + +The data is kept in memory, so no I/O occurs when getting or saving keys. It is +all written to a json file in the game save directory when the game is saved. + +Material info lookup +-------------------- + +A material info record has fields: + +* ``type``, ``index``, ``material`` + + DF material code pair, and a reference to the material object. + +* ``mode`` + + One of ``'builtin'``, ``'inorganic'``, ``'plant'``, ``'creature'``. + +* ``inorganic``, ``plant``, ``creature`` + + If the material is of the matching type, contains a reference to the raw object. + +* ``figure`` + + For a specific creature material contains a ref to the historical figure. + +Functions: + +* ``dfhack.matinfo.decode(type,index)`` + + Looks up material info for the given number pair; if not found, returns *nil*. + +* ``....decode(matinfo|item|plant|obj)`` + + Uses type-specific methods for retrieving the code pair. + +* ``dfhack.matinfo.find(token[,token...])`` + + Looks up material by a token string, or a pre-split string token sequence. + +* ``dfhack.matinfo.getToken(...)``, ``info:getToken()`` + + Applies ``decode`` and constructs a string token. + +* ``info:toString([temperature[,named]])`` + + Returns the human-readable name at the given temperature. + +* ``info:getCraftClass()`` + + Returns the classification used for craft skills. + +* ``info:matches(obj)`` + + Checks if the material matches job_material_category or job_item. + Accept dfhack_material_category auto-assign table. + +.. _lua_api_random: + +Random number generation +------------------------ + +* ``dfhack.random.new([seed[,perturb_count]])`` + + Creates a new random number generator object. Without any + arguments, the object is initialized using current time. + Otherwise, the seed must be either a non-negative integer, + or a list of such integers. The second argument may specify + the number of additional randomization steps performed to + improve the initial state. + +* ``rng:init([seed[,perturb_count]])`` + + Re-initializes an already existing random number generator object. + +* ``rng:random([limit])`` + + Returns a random integer. If ``limit`` is specified, the value + is in the range [0, limit); otherwise it uses the whole 32-bit + unsigned integer range. + +* ``rng:drandom()`` + + Returns a random floating-point number in the range [0,1). + +* ``rng:drandom0()`` + + Returns a random floating-point number in the range (0,1). + +* ``rng:drandom1()`` + + Returns a random floating-point number in the range [0,1]. + +* ``rng:unitrandom()`` + + Returns a random floating-point number in the range [-1,1]. + +* ``rng:unitvector([size])`` + + Returns multiple values that form a random vector of length 1, + uniformly distributed over the corresponding sphere surface. + The default size is 3. + +* ``fn = rng:perlin([dim]); fn(x[,y[,z]])`` + + Returns a closure that computes a classical Perlin noise function + of dimension *dim*, initialized from this random generator. + Dimension may be 1, 2 or 3 (default). + + +.. _lua-cpp-func-wrappers: + +C++ function wrappers +===================== + +.. contents:: + :local: + +Thin wrappers around C++ functions, similar to the ones for virtual methods. +One notable difference is that these explicit wrappers allow argument count +adjustment according to the usual lua rules, so trailing false/nil arguments +can be omitted. + +* ``dfhack.getOSType()`` + + Returns the OS type string from ``symbols.xml``. + +* ``dfhack.getDFVersion()`` + + Returns the DF version string from ``symbols.xml``. + +* ``dfhack.getDFHackVersion()`` +* ``dfhack.getDFHackRelease()`` +* ``dfhack.getDFHackBuildID()`` +* ``dfhack.getCompiledDFVersion()`` +* ``dfhack.getGitDescription()`` +* ``dfhack.getGitCommit()`` +* ``dfhack.getGitXmlCommit()`` +* ``dfhack.getGitXmlExpectedCommit()`` +* ``dfhack.gitXmlMatch()`` +* ``dfhack.isRelease()`` +* ``dfhack.isPrerelease()`` + + Return information about the DFHack build in use. + + .. note:: + ``getCompiledDFVersion()`` returns the DF version specified at compile time, + while ``getDFVersion()`` returns the version and typically the OS as well. + These do not necessarily match - for example, DFHack 0.34.11-r5 worked with + DF 0.34.10 and 0.34.11, so the former function would always return ``0.34.11`` + while the latter would return ``v0.34.10 `` or ``v0.34.11 ``. + +* ``dfhack.getDFPath()`` + + Returns the DF directory path. + +* ``dfhack.getHackPath()`` + + Returns the DFHack installation directory path (the folder where DFHack is installed). + This may be the ``hack`` folder within the DF installation, but you should not rely on this. + Specifically, the installation folder is extremely likely to be somewhere else when DFHack is installed from Steam. + Always use this function to get the DFHack installation directory path instead of hardcoding it. + +* ``dfhack.getConfigPath()`` + + Returns the DFHack config directory path (the folder where user-specific configuration files are stored). + This is currently the ``dfhack-config`` folder within the DF installation, but you should not rely on this as it is likely to change in the future. + Always use this function to get the DFHack config directory path instead of hardcoding it. + Avoid storing this value in a long-lived variable, as it's possible that in future versions of DFHack, it may be possible for the config directory to be changed at runtime. + +* ``dfhack.getSavePath()`` + + Returns the path to the current save directory, or *nil* if no save loaded. + +* ``dfhack.getTickCount()`` + + Returns the tick count in ms, exactly as DF ui uses. + +* ``dfhack.isWorldLoaded()`` + + Checks if the world is loaded. + +* ``dfhack.isMapLoaded()`` + + Checks if the world and map are loaded. + +* ``dfhack.isSiteLoaded()`` + + Checks if a site (e.g., a player fort) is loaded. + +* ``dfhack.df2utf(string)`` + + Convert a string from DF's CP437 encoding to UTF-8. + +* ``dfhack.df2console()`` + + Convert a string from DF's CP437 encoding to the correct encoding for the + DFHack console. + +.. warning:: + + When printing CP437-encoded text to the console (for example, names returned + from ``dfhack.units.getReadableName()``), use + ``print(dfhack.df2console(text))`` to ensure proper display on all platforms. + +* ``dfhack.utf2df(string)`` + + Convert a string from UTF-8 to DF's CP437 encoding. + +* ``dfhack.upperCp437(string)`` + + Return a version of the string with all letters capitalized. + Non-ASCII CP437 characters are capitalized if a CP437 version exists. + For example, ``ä`` is replaced by ``Ä``, but ``â`` is never capitalized. + + +* ``dfhack.lowerCp437(string)`` + + Return a version of the string with all letters in lower case. + Non-ASCII CP437 characters are downcased. For example, ``Ä`` is replaced by ``ä``. + +* ``dfhack.toSearchNormalized(string)`` + + Replace non-ASCII alphabetic characters in a CP437-encoded string with their + nearest ASCII equivalents, if possible, and returns a CP437-encoded string. + Note that the returned string may be longer than the input string. For + example, ``ä`` is replaced with ``a``, and ``æ`` is replaced with ``ae``. + +* ``dfhack.capitalizeStringWords(string)`` + + Return a version of the string with the first letter of each word capitalized. + The beginning of a word is determined by a space or quote ``"``. It is also + determined by an apostrophe ``'`` when preceded by a space or comma. + Non-ASCII CP437 characters will be capitalized if a CP437 version exists. + This function does not downcase characters. Use ``dfhack.lowerCp437`` + first, if desired. + +* ``dfhack.formatInt(num)`` + + Formats an integer value as a string according to the current system locale. + E.g., for American English, it would transform like: ``12345`` -> + ``'12,345'`` + +* ``dfhack.formatFloat(num)`` + + Formats a floating point value as a string according to the current system + locale. E.g., for American English, it would transform like: ``-12345.6789`` + -> ``'-12,345.678711'`` (because float imprecision). + +* ``dfhack.run_command(command[, ...])`` + + Run an arbitrary DFHack command, with the core suspended, and send output to + the DFHack console. The command can be passed as a table, multiple string + arguments, or a single string argument (not recommended - in this case, the + usual DFHack console tokenization is used). + + A ``command_result`` constant starting with ``CR_`` is returned, where ``CR_OK`` + indicates success. + + The following examples are equivalent:: + + dfhack.run_command({'ls', 'quick'}) + dfhack.run_command('ls', 'quick') + dfhack.run_command('ls quick') -- not recommended + +* ``dfhack.run_command_silent(command[, ...])`` + + Similar to ``run_command()``, but instead of printing to the console, + returns an ``output, command_result`` pair. ``output`` is a single string - + see ``dfhack.internal.runCommand()`` to obtain colors as well. + +Translation module +------------------ + +* ``dfhack.translation.translateName(name[,in_english[,only_last_name]])`` + + Convert a ``df.language_name`` (or only the last name part) to string. + +* ``dfhack.translation.generateName(name,language,type,major_selector,minor_selector)`` + + Dynamically generate a name using the same logic the game itself uses. + +Gui module +---------- + +Screens +~~~~~~~ + +* ``dfhack.gui.getCurViewscreen([skip_dismissed])`` + + Returns the topmost viewscreen. If ``skip_dismissed`` is *true*, + ignores screens already marked to be removed. + +* ``dfhack.gui.getFocusStrings(viewscreen)`` + + Returns a table of string representations of the current UI focuses. + The strings have a "screen/foo/bar/baz..." format e.g.:: + + [1] = "dwarfmode/Info/CREATURES/CITIZEN" + [2] = "dwarfmode/Squads" + +* ``dfhack.gui.matchFocusString(focus_string[, viewscreen])`` + + Returns ``true`` if the given ``focus_string`` is found in the current + focus strings, or as a prefix to any of the focus strings, or ``false`` + if no match is found. Matching is case insensitive. If ``viewscreen`` is + specified, gets the focus strings to match from the given viewscreen. + +* ``dfhack.gui.getCurFocus([skip_dismissed])`` + + Returns a list of focus strings for the current viewscreen. Equivalent to + ``dfhack.gui.getFocusStrings(dfhack.gui.getCurViewscreen(skip_dismissed))``. + +* ``dfhack.gui.getViewscreenByType(type[, depth])`` + + Returns the topmost viewscreen out of the top ``depth`` viewscreens with + the specified type (e.g., ``df.viewscreen_titlest``), or ``nil`` if none match. + If ``depth`` is not specified or is less than 1, all viewscreens are checked. + +* ``dfhack.gui.getDFViewscreen([skip_dismissed[, viewscreen]])`` + + Returns the topmost viewscreen not owned by DFHack. If ``skip_dismissed`` is + ``true``, ignores screens already marked to be removed. If ``viewscreen`` is + specified, starts the scan at the given viewscreen. + +* ``dfhack.gui.getWidget(container, [, ...])`` + + Returns the DF widget in the given widget container with the given name or + (zero-based) numeric index. You can follow a chain of widget containers by + passing additional names or indices. For example: + ``:lua ~dfhack.gui.getWidget(game.main_interface.info.labor, "Tabs", 0)`` + +* ``dfhack.gui.getWidgetChildren(container)`` + + Returns all the DF widgets in the given widget container. + +General-purpose selections +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +* ``dfhack.gui.getSelectedWorkshopJob([silent])`` +* ``dfhack.gui.getSelectedJob([silent])`` +* ``dfhack.gui.getSelectedUnit([silent])`` +* ``dfhack.gui.getSelectedItem([silent])`` +* ``dfhack.gui.getSelectedBuilding([silent])`` +* ``dfhack.gui.getSelectedCivZone([silent])`` +* ``dfhack.gui.getSelectedStockpile([silent])`` +* ``dfhack.gui.getSelectedPlant([silent])`` + + Returns the currently selected in-game object or the indicated thing + associated with the selected in-game object. For example, Calling + ``getSelectedJob`` when a building is selected will return the job associated + with the building (e.g., the ``ConstructBuilding`` job). If ``silent`` is + omitted or set to ``false`` and a selected object cannot be found, then an + error is printed to the console. + +* ``dfhack.gui.getAnyWorkshopJob(screen)`` +* ``dfhack.gui.getAnyJob(screen)`` +* ``dfhack.gui.getAnyUnit(screen)`` +* ``dfhack.gui.getAnyItem(screen)`` +* ``dfhack.gui.getAnyBuilding(screen)`` +* ``dfhack.gui.getAnyCivZone(screen)`` +* ``dfhack.gui.getAnyStockpile(screen)`` +* ``dfhack.gui.getAnyPlant(screen)`` + + Similar to the corresponding ``getSelected`` functions, but operate on the + given screen instead of the current screen and always return ``nil`` silently + on failure. + +Fortress mode +~~~~~~~~~~~~~ + +* ``dfhack.gui.getDwarfmodeViewDims()`` + + Returns dimensions of the displayed map viewport. See ``getPanelLayout()`` + in the ``gui.dwarfmode`` module for a more Lua-friendly version. + +* ``dfhack.gui.resetDwarfmodeView([pause])`` + + Resets the fortress mode sidebar menus and cursors to their default state. If + ``pause`` is true, also pauses the game. + +* ``dfhack.gui.pauseRecenter(pos[,pause])`` + ``dfhack.gui.pauseRecenter(x,y,z[,pause])`` + + Same as ``resetDwarfmodeView``, but also recenter if position is valid. If + ``pause`` is false, skip pausing. Respects ``RECENTER_INTERFACE_SHUTDOWN_MS`` + in DF's ``init.txt`` (the delay before input is recognized when a recenter + occurs.) + +* ``dfhack.gui.revealInDwarfmodeMap(pos[,center[,highlight]])`` + ``dfhack.gui.revealInDwarfmodeMap(x,y,z[,center[,highlight]])`` + + Centers the view on the given coordinates. If ``center`` is true, make sure + the position is in the exact center of the view, else just bring it on screen. + If ``highlight`` is true, then mark the target tile with a pulsing highlight + until the player clicks somewhere else. + + ``pos`` can be a ``df.coord`` instance or a table assignable to a ``df.coord`` + (see `lua-api-table-assignment`), + e.g.:: + + {x = 5, y = 7, z = 11} + getSelectedUnit().pos + copyall(df.global.cursor) + + If the position is invalid, the function will simply ensure the current + window position is clamped between valid values. + +* ``dfhack.gui.refreshSidebar()`` + + Refreshes the fortress mode sidebar. This can be useful when making changes to + the map, for example, because DF only updates the sidebar when the cursor + position changes. + +* ``dfhack.gui.inRenameBuilding()`` + + Returns ``true`` if a building is being renamed. + +Announcements +~~~~~~~~~~~~~ + +* ``dfhack.gui.writeToGamelog(text)`` + + Writes a string to :file:`gamelog.txt` without doing an announcement. + +* ``dfhack.gui.makeAnnouncement(type,flags,pos,text[,color[,is_bright]])`` + + Adds an announcement with given announcement_type, text, color, and brightness. + + The announcement is written to :file:`gamelog.txt`. The announcement_flags + argument provides a custom set of :file:`announcements.txt` options, + which specify if the message should actually be displayed in the + announcement list, and whether to recenter or show a popup. + + Returns the index of the new announcement in ``df.global.world.status.reports``, or -1. + +* ``dfhack.gui.addCombatReport(unit,slot,report_index[,update_alert])`` + + Adds the report with the given index (returned by makeAnnouncement) + to the specified group of the given unit. If ``update_alert`` is ``true``, + an alert badge will appear on the left side of the screen if not already visible. + Returns ``true`` on success. + +* ``dfhack.gui.addCombatReportAuto(unit,flags,report_index)`` + + Adds the report with the given index to the appropriate group(s) of the given unit + based on the unit's current job and as requested by the flags. + Always updates alert badges. Returns ``true`` on any success. + +* ``dfhack.gui.showAnnouncement(text[,color[,is_bright]])`` + + Adds a regular announcement with given text, color, and brightness. + The announcement type is always ``df.announcement_type.REACHED_PEAK``, + which uses the alert badge for ``df.announcement_alert_type.GENERAL``. + +* ``dfhack.gui.showZoomAnnouncement(type,pos,text[,color[,is_bright]])`` + + Like above, but also specifies a position you can zoom to from the announcement menu, + as well as being able to set the announcement type. + +* ``dfhack.gui.showPopupAnnouncement(text[,color[,is_bright]])`` + + Displays a megabeast-style modal announcement window. + DF is currently ignoring the color and brightness settings + (see: `bug report `_.) + Add ``[C:`` color ``:0:`` bright ``]`` (where color is 0-7 and bright is 0-1) + in front of your text string to force the popup text to be colored. + + Text is run through a parser as it is converted into a markup text box. + The parser accepts tokens in square brackets (``[`` ``]``.) + Use ``[[`` and ``]]`` to include actual square brackets in text. + + The following tokens are accepted: + + ``[R]``: (NEW_LINE) Ends the current line and begins on the next. + + ``[B]``: (BLANK_LINE) Ends the current line and adds an additional blank line, + beginning on the line after that. + + ``[P]``: (INDENT) Ends the current line and begins four spaces indented on the next. + + ``[CHAR:`` n ``]``, ``[CHAR:~`` ch ``]``: Add a single character. First version + takes a base-10 integer ``n`` representing a CP437 character. + Second version accepts a character ``ch`` instead. ``"[CHAR:154]"`` and + ``"[CHAR:~"..string.char(154).."]"`` both result in ``Ãœ``. Use ``[CHAR:32]`` or + ``[CHAR:~ ]`` to add extra spaces, which would normally be trimmed by the parser. + + ``[LPAGE:`` link_type ``:`` id ``]``, ``[LPAGE:`` link_type ``:`` id ``:`` subid ``]``: + Start a ``markup_text_linkst``. These are intended for Legends mode page links and + don't work in popups. The text will just be colored based on ``link_type``. + Valid link types are: ``HF`` (``HIST_FIG``,) ``SITE``, ``ARTIFACT``, ``BOOK``, + ``SR`` (``SUBREGION``,) ``FL`` (``FEATURE_LAYER``,) ``ENT`` (``ENTITY``,) + ``AB`` (``ABSTRACT_BUILDING``,) ``EPOP`` (``ENTITY_POPULATION``,) ``ART_IMAGE``, + ``ERA``, ``HEC``. + ``subid`` is only used for ``AB`` and ``ART_IMAGE``. ``[/LPAGE]`` ends the link text. + + ``[C:`` screenf ``:`` screenb ``:`` screenbright ``]``: Color text. Sets the + respective values in ``df.global.gps`` and then sets text color. + ``color`` = ``screenf``, ``bright`` = ``screenbright``, ``screenb`` does nothing + since popup backgrounds are always black. + Example: ``"Light gray, [C:4:0:0]red, [C:4:0:1]orange, [C:7:0:0]light gray."`` + + ``[KEY:`` n ``]``: Keybinding. Shows the (first) keybinding for the + ``df.interface_key`` ``n``. The keybinding will be displayed in light green, but + the previous text color will be restored afterwards. + +* ``dfhack.gui.showAutoAnnouncement(type,pos,text[,color[,is_bright[,unit_a[,unit_d]]]])`` + + Uses the type to look up options from announcements.txt, and calls the above + operations accordingly. The units are used to call ``addCombatReportAuto``. + +* ``dfhack.gui.autoDFAnnouncement(report,text)`` + ``dfhack.gui.autoDFAnnouncement(type,pos,text[,color[,is_bright[,unit_a[,unit_d[,is_sparring]]]]])`` + + Takes a ``df.announcement_infost`` (see: + `structure definition `_) + and a string and processes them just like DF does. Can also be built from parameters instead of + an ``announcement_infost``. Setting ``is_sparring`` to ``true`` means the report will be added + to sparring logs (if applicable) rather than hunting or combat. + + The announcement will not display if units are involved and the player can't see + them (or hear, for adventure mode sound announcement types.) + Returns ``true`` if a report was created or repeated. + For detailed info on why an announcement failed to display, enable + ``debugfilter set Debug core gui`` in the DFHack console. + If you want a guaranteed announcement, use ``dfhack.gui.showAutoAnnouncement`` instead. + +* ``dfhack.gui.getMousePos([allow_out_of_bounds])`` + + Returns the map coordinates of the map tile the mouse is over as a table of + ``{x, y, z}``. If the cursor is not over a valid tile, returns ``nil``. To + allow the function to return coordinates outside of the map, set + ``allow_out_of_bounds`` to ``true``. + +Other +~~~~~ + +* ``dfhack.gui.getDepthAt(x, y)`` + + Returns the distance from the z-level of the tile at map coordinates (x, y) to + the closest rendered ground z-level below. Defaults to 0, unless overridden by + plugins. + +Job module +---------- + +* ``dfhack.job.cloneJobStruct(job)`` + + Creates a deep copy of the given job. + +* ``dfhack.job.createLinked()`` + + Create a job and immediately link it into the global job list. + +* ``dfhack.job.printJobDetails(job)`` + + Prints info about the job. + +* ``dfhack.job.printItemDetails(jobitem,idx)`` + + Prints info about the job item. + +* ``dfhack.job.removeJob(job)`` + + Cancels a job, cleans up all references to it, and removes it from the world. + +* ``dfhack.job.addGeneralRef(job, type, id)`` + + Create a general reference of the given type, pointing to the object with the + specified id, and add the created general reference to the provided job. + +* ``dfhack.job.getGeneralRef(job, type)`` + + Searches for a general_ref with the given type. + +* ``dfhack.job.getSpecificRef(job, type)`` + + Searches for a specific_ref with the given type. + +* ``dfhack.job.assignToWorkshop(job, workshop)`` + + Assign job to workshop (i.e. establish the bidirectional link between the job + and the workshop). Does nothing and returns ``false`` if the workshop already + has the maximum of ten jobs. + +* ``dfhack.job.getHolder(job)`` + + Returns the building holding the job. + +* ``dfhack.job.getWorker(job)`` + + Returns the unit performing the job. + +* ``dfhack.job.setJobCooldown(building,worker,cooldown)`` + + Prevent the worker from taking jobs at the specified workshop for the + specified cooldown period (in ticks). This doesn't decrease the cooldown + period in any circumstances. + +* ``dfhack.job.addWorker(job, unit)`` + + Assign the specified job to the provided unit, unless the unit already has an + active job. Also cleans up a potential job posting for the provided job. + +* ``dfhack.job.removeWorker(job,cooldown)`` + + Removes the worker from the specified workshop job, and sets the cooldown + period (using the same logic as ``setJobCooldown``). Returns *true* on + success. + +* ``dfhack.job.checkBuildingsNow()`` + + Instructs the game to check buildings for jobs next frame and assign workers. + +* ``dfhack.job.checkDesignationsNow()`` + + Instructs the game to check designations for jobs next frame and assign workers. + +* ``dfhack.job.is_equal(job1,job2)`` + + Compares important fields in the job and nested item structures. + +* ``dfhack.job.is_item_equal(job_item1,job_item2)`` + + Compares important fields in the job item structures. + +* ``dfhack.job.linkIntoWorld(job,new_id)`` + + Adds job into ``df.global.job_list``, and if new_id + is true, then also sets its id and increases + ``df.global.job_next_id`` + +* ``dfhack.job.listNewlyCreated(first_id)`` + + Returns the current value of ``df.global.job_next_id``, and + if there are any jobs with ``first_id <= id < job_next_id``, + a lua list containing them. + +* ``dfhack.job.attachJobItem(job, item, role, filter_idx, insert_idx)`` + + Attach a real item to this job. If the item is intended to satisfy a job_item + filter, the index of that filter should be passed in ``filter_idx``; otherwise, + pass ``-1``. Similarly, if you don't care where the item is inserted, pass + ``-1`` for ``insert_idx``. The ``role`` param is a ``df.job_role_type``. + If the item needs to be brought to the job site, then the value should be + ``df.job_role_type.Hauled``. + +* ``dfhack.job.isSuitableItem(job_item, item_type, item_subtype)`` + + Does basic sanity checks to verify if the suggested item type matches + the flags in the job item. + +* ``dfhack.job.isSuitableMaterial(job_item, mat_type, mat_index, item_type)`` + + Likewise, if replacing material. + +* ``dfhack.job.getName(job)`` + + Returns the job's description, as seen in the Units and Jobs screens. + +* ``dfhack.job.getManagerOrderName(manager_order)`` + + Returns the manager order's description, as seen in the Work orders screen. + +Hotkey module +------------- + +* ``dfhack.hotkey.addKeybind(keyspec, command)`` + + Creates a new keybind with the provided keyspec (see the `keybinding` documentation + for details on format). + Returns false on failure to create keybind. + +* ``dfhack.hotkey.removeKeybind(keyspec, [match_focus=true, command])`` + + Removes keybinds matching the provided keyspec. + If match_focus is set, the focus portion of the keyspec is matched against. + If command is provided and not an empty string, the command is matched against. + Returns false if no keybinds were removed. + +* ``dfhack.hotkey.listActiveKeybinds()`` + + Returns a list of keybinds active within the current context. + The items are tables with the following attributes: + :spec: The keyspec for the hotkey + :command: The command the hotkey runs when pressed + +* ``dfhack.hotkey.listAllKeybinds()`` + + Returns a list of all keybinds currently registered. + The items are tables with the following attributes: + :spec: The keyspec for the hotkey + :command: The command the hotkey runs when pressed + +* ``dfhack.hotkey.requestKeybindingInput([cancel=false])`` + + Enqueues or cancels a request that the next hotkey-compatible input is saved + and not processed, retrievable with ``dfhack.hotkey.getKeybindingInput()``. + If cancel is true, any current request is cancelled. + +* ``dfhack.hotkey.getKeybindingInput()`` + + Reads the latest saved keybind input that was requested. + Returns a keyspec string for the input, or nil if no input has been saved. + +* ``dfhack.hotkey.isDisruptiveKeybind(keyspec)`` + + Determines if the provided keyspec could be disruptive to the game experience. + This includes the majority of standard characters and special keys such as escape, + backspace, and return when lacking modifiers other than Shift. + +Units module +------------ + +* ``dfhack.units.isActive(unit)`` + + The unit is active (non-dead and on the map). + +* ``dfhack.units.isVisible(unit)`` + + The unit is on a visible map tile. Doesn't account for sneaking. + +* ``dfhack.units.isCitizen(unit[,include_insane])`` + + The unit is a non-dead sane citizen of the fortress; wraps the + same checks the game uses to decide game-over by extinction, + with an additional sanity check. You can identify citizens, + regardless of their sanity, by passing ``true`` as the optional + second parameter. + +* ``dfhack.units.isResident(unit[,include_insane])`` + + The unit is a resident of the fortress. Same ``include_insane`` semantics as + ``isCitizen``. + +* ``dfhack.units.isFortControlled(unit)`` + + Similar to ``dfhack.units.isCitizen(unit)``, but is based on checks + for units hidden in ambush, and includes tame animals. Returns *false* + if not in fort mode. + +* ``dfhack.units.isOwnCiv(unit)`` + + The unit belongs to the player's civilization. + +* ``dfhack.units.isOwnGroup(unit)`` + + The unit belongs to the player's group. + +* ``dfhack.units.isOwnRace(unit)`` + + The unit belongs to the player's race. + +* ``dfhack.units.isAlive(unit)`` + + The unit isn't dead or undead. Naturally inorganic is okay. + +* ``dfhack.units.isDead(unit)`` + + The unit is completely dead and passive, or a ghost. Equivalent to + ``dfhack.units.isKilled(unit) or dfhack.units.isGhost(unit)``. + +* ``dfhack.units.isKilled(unit)`` + + The unit has been killed. + +* ``dfhack.units.isSane(unit)`` + + The unit is normally capable of rational action. I.e., not dead, insane, zombie, + nor crazed (unless active werebeast). + +* ``dfhack.units.isCrazed(unit)`` + + The unit is berserk and will attack all other creatures except crazed members of + its own species. (Can be modified by curses.) + +* ``dfhack.units.isGhost(unit)`` + + The unit is a ghost. + +* ``dfhack.units.isHidden(unit)`` + + The unit is hidden to the player, accounting for sneaking. Works for any game mode. + +* ``dfhack.units.isHidingCurse(unit)`` + + The unit is currently hiding a curse (i.e., vampire). + +* ``dfhack.units.isMale(unit)`` +* ``dfhack.units.isFemale(unit)`` +* ``dfhack.units.isBaby(unit)`` +* ``dfhack.units.isChild(unit)`` +* ``dfhack.units.isAdult(unit)`` + + Simple unit property checks + +* ``dfhack.units.isGay(unit)`` + + Not willing to breed. Also includes any creature caste without a gender. + +* ``dfhack.units.isNaked(unit[,no_items])`` + + Not wearing anything (including rings, etc.). Can optionally check for + empty inventory. + +* ``dfhack.units.isVisiting(unit)`` + + The unit is visiting. E.g., merchants, diplomats, and travelers. + +* ``dfhack.units.isTrainableHunting(unit)`` + + The unit is trainable for hunting. + +* ``dfhack.units.isTrainableWar(unit)`` + + The unit is trainable for war. + +* ``dfhack.units.isTrained(unit)`` + + The unit is trained for hunting or war, or is non-wild and non-domesticated. + +* ``dfhack.units.isHunter(unit)`` + + The unit is a trained hunter. + +* ``dfhack.units.isWar(unit)`` + + The unit is trained for war. + +* ``dfhack.units.isTame(unit)`` +* ``dfhack.units.isTamable(unit)`` +* ``dfhack.units.isDomesticated(unit)`` +* ``dfhack.units.isMarkedForTraining(unit)`` +* ``dfhack.units.isMarkedForTaming(unit)`` +* ``dfhack.units.isMarkedForWarTraining(unit)`` +* ``dfhack.units.isMarkedForHuntTraining(unit)`` +* ``dfhack.units.isMarkedForSlaughter(unit)`` +* ``dfhack.units.isMarkedForGelding(unit)`` +* ``dfhack.units.isGeldable(unit)`` +* ``dfhack.units.isGelded(unit)`` +* ``dfhack.units.isEggLayer(unit)`` +* ``dfhack.units.isEggLayerRace(unit)`` +* ``dfhack.units.isGrazer(unit)`` +* ``dfhack.units.isMilkable(unit)`` + + Simple unit property checks. + +* ``dfhack.units.isForest(unit)`` + + The unit is of the forest. + +* ``dfhack.units.isMischievous(unit)`` + + The unit is mischievous and will randomly pull levers, etc. + +* ``dfhack.units.isAvailableForAdoption(unit)`` + + The unit is available for adoption. + +* ``dfhack.units.isPet(unit)`` + + Unit has pet owner. + +* ``dfhack.units.hasExtravision(unit)`` +* ``dfhack.units.isOpposedToLife(unit)`` +* ``dfhack.units.isBloodsucker(unit)`` + + Simple checks of caste attributes that can be modified by curses. + +* ``dfhack.units.isDwarf(unit)`` + + The unit is of the same race for the fortress. (Includes active werebeasts.) + +* ``dfhack.units.isAnimal(unit)`` +* ``dfhack.units.isMerchant(unit)`` +* ``dfhack.units.isDiplomat(unit)`` + + Simple unit type checks. + +* ``dfhack.units.isVisitor(unit)`` + + The unit is a regular visitor with no special purpose (e.g., merchant). + +* ``dfhack.units.isWildlife(unit)`` + + The unit is surface or cavern wildlife. + +* ``dfhack.units.isAgitated(unit)`` + + The unit is an agitated creature. + +* ``dfhack.units.isInvader(unit)`` + + The unit is an active invader or marauder. + +* ``dfhack.units.isUndead(unit[,hiding_curse])`` + + The unit is undead. Pass ``true`` as the optional second parameter to + count undead hiding their curse (i.e., vampires). + +* ``dfhack.units.isNightCreature(unit)`` +* ``dfhack.units.isSemiMegabeast(unit)`` +* ``dfhack.units.isMegabeast(unit)`` +* ``dfhack.units.isTitan(unit)`` +* ``dfhack.units.isForgottenBeast(unit)`` +* ``dfhack.units.isDemon(unit)`` + + Simple enemy type checks. + +* ``dfhack.units.isDanger(unit)`` + + The unit is dangerous and probably hostile. This includes night creatures, + semi-megabeasts, invaders, agitated wildlife, crazed units, and Great Dangers + (see below). + +* ``dfhack.units.isGreatDanger(unit)`` + + The unit is of Great Danger. This includes megabeasts, titans, + forgotten beasts, and demons. + +* ``dfhack.units.isUnitInBox(unit, pos1, pos2)`` +* ``dfhack.units.isUnitInBox(unit,x1,y1,z1,x2,y2,z2)`` + + Returns true if the unit is within a box defined by the + specified coordinates. + +* ``dfhack.units.getUnitsInBox(pos1, pos2[, filter])`` +* ``dfhack.units.getUnitsInBox(x1,y1,z1,x2,y2,z2[,filter])`` + + Returns a table of all units within the specified coordinates. + If the ``filter`` argument is given, only units where ``filter(unit)`` + returns true will be included. + +* ``dfhack.units.getUnitByNobleRole(role_name)`` + + Returns the unit assigned to the given noble role, if any. + ``role_name`` must be one of the position codes associated with the + active fort or civilization government. For example: + ``CAPTAIN_OF_THE_GUARD``, ``MAYOR``, or ``BARON``. + Note that if more than one unit has the role, only the first will be + returned. See ``getUnitsByNobleRole`` below for retrieving all units + with a particular role. + +* ``dfhack.units.getUnitsByNobleRole(role_name)`` + + Returns a list of units (possibly empty) assigned to the given noble role. + +* ``dfhack.units.getCitizens([exclude_residents[,include_insane]])`` + + Returns a list of all living, sane citizens and residents that are + currently on the map. Can ``exclude_residents`` or ``include_insane`` + (both default to ``false``). + +* ``dfhack.units.getPosition(unit)`` + + Returns the true *x,y,z* of the unit, or *nil* if invalid. You should + generally use this method instead of reading *unit.pos* directly since + that field can be inaccurate when the unit is caged. + +* ``dfhack.units.teleport(unit, pos)`` + + Moves the specified unit and any riders to the target coordinates, setting + tile occupancy flags appropriately. Returns true if successful. + +* ``dfhack.units.getGeneralRef(unit, type)`` + + Searches for a ``general_ref`` with the given type. + +* ``dfhack.units.getSpecificRef(unit, type)`` + + Searches for a ``specific_ref`` with the given type. + +* ``dfhack.units.getContainer(unit)`` + + Returns the container (i.e., cage) holding the unit or *nil*. + +* ``dfhack.units.getOuterContainerRef(unit)`` + + Returns a table (in the style of a ``specific_ref`` struct) of the + outermost object that contains the unit (or one of the unit itself). + The ``type`` field contains a + ``specific_ref_type`` of ``UNIT``, ``ITEM_GENERAL``, or ``VERMIN_EVENT``. + The ``object`` field contains a pointer to a unit, item, or vermin, + respectively. + +* ``dfhack.units.getIdentity(unit)`` + + Returns the false identity of the unit if it has one, or *nil*. + +* ``dfhack.units.getNemesis(unit)`` + + Returns the nemesis record of the unit if it has one, or *nil*. + +* ``dfhack.units.setNickname(unit, nick)`` + + Sets the unit's nickname properly. + +* ``dfhack.units.getVisibleName(unit)`` + + Returns the ``language_name`` object visible in game, accounting for + false identities. + +* ``dfhack.units.assignTrainer(unit[,trainer_id])`` +* ``dfhack.units.unassignTrainer(unit)`` + + Assigns (or unassigns) a trainer for the specified trainable unit. The + trainer ID can be omitted if "any trainer" is desired. Returns a boolean + indicating whether the operation was successful. + +* ``dfhack.units.makeown(unit)`` + + Makes the selected unit a member of the current fortress and site. + Note that this operation may silently fail for any of several reasons, + so it may be prudent to check if the operation has succeeded by using + ``dfhack.units.isOwnCiv`` or another appropriate predicate on the unit + in question. + +* ``dfhack.units.setPathGoal(unit, pos, goal)`` + + Set target coordinates and goal (of type ``df.unit_path_goal``) for the given + unit. In case of a change, also clears the unit's current path. + +* ``dfhack.units.create(race, caste)`` + + Creates a new unit from scratch. The unit will be added to the + ``world.units.all`` vector, but not to the ``world.units.active`` vector. + The unit will not have an associated historical figure, nemesis record, + map position, labors, or any group associations. The unit *will* have a + race, caste, name, soul, and initialized body and mind (including + personality). The unit must be configured further as needed and put into + play by the client. + +* ``dfhack.units.getCasteRaw(unit)`` +* ``dfhack.units.getCasteRaw(race, caste)`` + + Returns the relevant ``caste_raw`` or *nil*. + +* ``dfhack.units.getPhysicalAttrValue(unit, attr_type)`` +* ``dfhack.units.getMentalAttrValue(unit, attr_type)`` + + Computes the effective attribute value, including curse effect. + +* ``dfhack.units.casteFlagSet(race, caste, flag)`` + + Returns whether the given ``df.caste_raw_flags`` flag is set for the given + race and caste. + +* ``dfhack.units.getMiscTrait(unit, type[, create])`` + + Finds (or creates if requested) a misc trait object with the given id. + +* ``dfhack.units.getRaceNameById(race)`` +* ``dfhack.units.getRaceName(unit)`` + + Get raw token name (e.g., "DWARF"). + +* ``dfhack.units.getRaceReadableNameById(race)`` +* ``dfhack.units.getRaceReadableName(unit)`` +* ``dfhack.units.getRaceNamePluralById(race)`` +* ``dfhack.units.getRaceNamePlural(unit)`` + + Get human-readable name (e.g., "dwarf" or "dwarves"). + +* ``dfhack.units.getRaceBabyNameById(race[,plural])`` +* ``dfhack.units.getRaceBabyName(unit[,plural])`` +* ``dfhack.units.getRaceChildNameById(race[,plural])`` +* ``dfhack.units.getRaceChildName(unit[,plural])`` + + Get human-readable baby or child name (e.g., "dwarven baby" or + "dwarven child"). + +* ``dfhack.units.getReadableName(unit or historical_figure[, skip_english])`` + + Returns a string that includes the native and english language name (if + ``skip_english`` is not ``true``) of the unit (if any), the race of the unit + (if different from fort), whether it is trained for war or hunting, any + syndrome-given descriptions (such as "necromancer"), the training level (if + tame), and profession or noble role. If a ``historical_figure`` is passed + instead of a unit, some information (e.g., agitation status) is not + available, and the profession may be different (e.g., "Monk") from what is + displayed in fort mode. + +* ``dfhack.units.getAge(unit[, true_age])`` + + Returns the age of the unit in years as a floating-point value. + If ``true_age`` is true, ignores false identities. + +* ``dfhack.units.getKillCount(unit)`` + + Returns the number of units the unit has killed. + +* ``dfhack.units.getNominalSkill(unit, skill[, use_rust])`` + + Retrieves the nominal skill level for the given unit. If ``use_rust`` + is *true*, subtracts the rust penalty. + +* ``dfhack.units.getEffectiveSkill(unit, skill)`` + + Computes the effective rating for the given skill, taking into account + skill rust, exhaustion, pain, etc. + +* ``dfhack.units.getExperience(unit, skill[, total])`` + + Returns the experience value for the given skill. If ``total`` is true, + adds experience implied by the current skill level. + +* ``dfhack.units.isValidLabor(unit, unit_labor)`` + + Returns whether the indicated labor is settable for the given unit. + +* ``dfhack.units.setLaborValidity(unit_labor, isValid)`` + + Sets the given labor to the given (boolean) validity for all units that are + part of your fortress civilization. Valid labors are allowed to be toggled + in the in-game labor management screens (including DFHack's `labor + manipulator screen `). + +* ``dfhack.units.setAutomaticProfessions(unit)`` + + Set appropriate labors on a unit based on current work detail settings. + +* ``dfhack.units.computeMovementSpeed(unit)`` + + Computes number of frames * 100 it takes the unit to move in its current + state of mind and body. **Currently broken due to move speed changes, + will always return 0!** + +* ``dfhack.units.computeSlowdownFactor(unit)`` + + Meandering and floundering in liquid introduces additional slowdown. + It is random, but the function computes and returns the expected mean + factor as a float. + +* ``dfhack.units.getNoblePositions(unit or historical_figure)`` + + Returns a list of tables describing noble position assignments, or *nil*. + Every table has fields ``entity``, ``assignment``, and ``position``. + +* ``dfhack.units.getProfession(unit)`` + + Returns unit's profession ID (``df.profession``), accounting for + false identity. + +* ``dfhack.units.getProfessionName(unit[,ignore_noble[,plural[,land_title]]])`` +* ``dfhack.units.getProfessionName(historical_figure[,ignore_noble[,plural[,land_title]]])`` + + Retrieves the profession name using custom profession, noble assignments, + or raws. The ``ignore_noble`` boolean disables the use of noble positions + ("Prisoner", "Slave", and noble spouse titles included). The ``land_title`` + boolean causes ``of Sitename`` to be appended when applicable. If a + ``historical_figure`` is passed instead of a unit, some information (e.g., + agitation status) is not available, and the profession may be different + (e.g., "Monk") from what is displayed in fort mode. + +* ``dfhack.units.getCasteProfessionName(race, caste, prof_id[, plural])`` + + Retrieves the profession name for the given race and caste using raws. + +* ``dfhack.units.getProfessionColor(unit[,ignore_noble])`` + + Retrieves the color associated with the profession, using noble assignments + or raws. The ``ignore_noble`` boolean disables the use of noble positions. + +* ``dfhack.units.getCasteProfessionColor(race, caste, prof_id)`` + + Retrieves the profession color for the given race and caste using raws. + +* ``dfhack.units.getGoalType(unit[,goalIndex])`` + + Retrieves the goal type of the dream that the given unit has. + By default the goal of the first dream is returned. + The ``goalIndex`` parameter may be used to retrieve additional dream goals. + Currently only one dream per unit is supported by Dwarf Fortress. + Support for multiple dreams may be added in future versions of + Dwarf Fortress. + +* ``dfhack.units.getGoalName(unit[,goalIndex])`` + + Retrieves the short name describing the goal of the dream that the given + unit has. By default the goal of the first dream is returned (see above). + +* ``dfhack.units.isGoalAchieved(unit[,goalIndex])`` + + Checks if given unit has achieved the goal of the dream. + By default the status of the goal of the first dream is returned (see above). + +* ``dfhack.units.getMainSocialActivity(unit)`` +* ``dfhack.units.getMainSocialEvent(unit)`` + + Return the ``df.activity_entry`` or ``df.activity_event`` representing the + unit's current social activity. + +* ``dfhack.units.hasUnbailableSocialActivity(unit)`` + + Unit has an uninterruptible social activity (e.g. a purple "Socialize!"). + +* ``dfhack.units.isJobAvailable(unit [, preserve_social])`` + + Check whether a unit can be assigned to (i.e. is looking for) a job. Will + return ``true`` if the unit is engaged in "green" social activities, unless + the boolean ``preserve_social`` is true. Will never interrupt uninterruptible + social activities (e.g. a purple "Socialize!"). + +* ``dfhack.units.getFocusPenalty(unit, need_type [, need_type, ...])`` + + Get largest (i.e. most negative) focus penalty associated to a collection of + ``df.need_type`` arguments. Returns a number strictly greater than 400 if the + unit does not have any of the requested needs. + +* ``dfhack.units.getStressCategory(unit)`` + + Returns a number from 0-6 indicating stress. 0 is most stressed; 6 is least. + Note that 0 is guaranteed to remain the most stressed but 6 could change in + the future. + +* ``dfhack.units.getStressCategoryRaw(stress_level)`` + + Identical to ``getStressCategory`` but takes a raw stress level instead + of a unit. + +* ``dfhack.units.getStressCutoffs()`` + + Returns a table of the cutoffs used by the above stress level functions. + +Action Timer API +~~~~~~~~~~~~~~~~ + +This is an API to allow manipulation of unit action timers, to speed them up or slow +them down. All functions in this API have overflow/underflow protection when modifying +action timers (the value will cap out). Actions with a timer of 0 (or less) will not +be modified as they are completed (or invalid in the case of negatives). +Timers will be capped to go no lower than 1. +``affectedActionType`` parameters are values from the DF enum ``unit_action_type`` +(e.g., ``df.unit_action_type.Move``). +``affectedActionTypeGroup`` parameters are values from the (custom) DF enum +``unit_action_type_group`` (see +`unit_action_type definition `_ +for which action types each group contains). They are as follows: + + * ``All`` + * ``Movement`` + * ``MovementFeet`` (affects only walking and crawling speed. If you need to + differentiate between walking and crawling, check the unit's ``flags1.on_ground`` flag, + like the Pegasus boots do in the `modding-guide`). + * ``MovementFeet`` (for walking speed, such as with pegasus boots from the `modding-guide`). + * ``Combat`` (includes bloodsucking). + * ``Work`` + +API functions: + +* ``dfhack.units.subtractActionTimers(unit, amount, affectedActionType)`` + + Subtract ``amount`` (32-bit integer) from the timers of any actions the unit is performing + of ``affectedActionType`` (usually one or zero actions in normal gameplay). Negative + amount adds to timers. + +* ``dfhack.units.subtractGroupActionTimers(unit, amount, affectedActionTypeGroup)`` + + Subtract ``amount`` (32-bit integer) from the timers of any actions the unit is performing + that match the ``affectedActionTypeGroup`` category. Negative amount adds to timers. + +* ``dfhack.units.multiplyActionTimers(unit, amount, affectedActionType)`` + + Multiply the timers of any actions of ``affectedActionType`` the unit is performing by + ``amount`` (float) (usually one or zero actions in normal gameplay). + +* ``dfhack.units.multiplyGroupActionTimers(unit, amount, affectedActionTypeGroup)`` + + Multiply the timers of any actions that match the ``affectedActionTypeGroup`` category + the unit is performing by ``amount`` (float). + +* ``dfhack.units.setActionTimers(unit, amount, affectedActionType)`` + + Set the timers of any action the unit is performing of ``affectedActionType`` to ``amount`` + (32-bit integer) (usually one or zero actions in normal gameplay). + +* ``dfhack.units.setGroupActionTimers(unit, amount, affectedActionTypeGroup)`` + + Set the timers of any action the unit is performing that match the + ``affectedActionTypeGroup`` category to ``amount`` (32-bit integer). + +Military module +--------------- + +* ``dfhack.military.makeSquad(assignment_id)`` + + Creates a new squad associated with the assignment (i.e., + ``df::entity_position_assignment``, via ``id``) and returns it. + Fails if a squad already exists that is associated with that assignment, or if + the assignment is not a fort mode player controlled squad. + Note: This function does not name the squad. Consider setting a nickname + (under ``squad.name.nickname``), and/or filling out the ``language_name`` object + at ``squad.name``. The returned squad is otherwise complete and requires no more + setup to work correctly. + +* ``dfhack.military.updateRoomAssignments(squad_id, assignment_id, squad_use_flags)`` + + Sets the sleep, train, indiv_eq, and squad_eq flags when training at a barracks. + +* ``dfhack.military.getSquadName(squad_id)`` + + Returns the name of a squad as a string. + +* ``dfhack.military.removeFromSquad(unit_id)`` + + Removes a unit from its squad. Unsets the unit's + military information (i.e., ``unit.military.squad_id`` and + ``unit.military.squad_pos``), the squad's position information (i.e., + ``squad.positions[squad_pos].occupant``), modifies the unit's entity links + to indicate former squad membership or command, and creates a corresponding + world history event. + + * ``dfhack.military.addToSquad(unit_id, squad_id, squad_pos)`` + + Adds a unit to a squad. Sets the unit's + military information (i.e., ``unit.military.squad_id`` and + ``unit.military.squad_pos``), the squad's position information (i.e., + ``squad.positions[squad_pos].occupant``), adds a unit's entity links to + indicate squad membership. Does not currently add world history events. + If ``squad_pos`` is -1, the unit will be added to the first open slot in + the squad. + + This API cannot be used to set or change the leader of a squad and will fail + if ``squad_pos`` is specified as 0 or if ``squad_pos`` is specified as -1 and + the squad leader position is currently vacant. It will also fail if + the requested squad position is already occupied, the squad does not exist, + the unit does not exist, or the requested unit is already a member of another + squad. + +Items module +------------ + +* ``dfhack.items.findType(string)`` + + Finds an item type by string and returns the ``df.item_type``. String is + case-sensitive (e.g., "TOOL"). + +* ``dfhack.items.findSubtype(string)`` + + Finds an item subtype by string and returns the subtype or *-1*. String is + case-sensitive (e.g., "TOOL:ITEM_TOOL_HIVE"). + +* ``dfhack.items.isCasteMaterial(item_type)`` + + Returns *true* if this item type uses a creature/caste pair as its material. + +* ``dfhack.items.getSubtypeCount(item_type)`` + + Returns the number of raw-defined subtypes of the given item type, or *-1* + if not applicable. + +* ``dfhack.items.getSubtypeDef(item_type, subtype)`` + + Returns the raw definition for the given item type and subtype, or *nil* + if invalid. + +* ``dfhack.items.getGeneralRef(item, type)`` + + Searches for a general_ref with the given type. + +* ``dfhack.items.getSpecificRef(item, type)`` + + Searches for a specific_ref with the given type. + +* ``dfhack.items.getOwner(item)`` + + Returns the owner unit or *nil*. + +* ``dfhack.items.setOwner(item,unit)`` + + Replaces the owner of the item. If unit is *nil*, removes ownership. + Returns *false* in case of error. + +* ``dfhack.items.getContainer(item)`` + + Returns the item's container item or *nil*. + +* ``dfhack.items.getOuterContainerRef(item)`` + + Returns a table (in the style of a ``specific_ref`` struct) of the outermost object + that contains the item (or one of the item itself.) The ``type`` field contains a + ``specific_ref_type`` of ``UNIT``, ``ITEM_GENERAL``, or ``VERMIN_EVENT``. + The ``object`` field contains a pointer to a unit, item, or vermin, respectively. + +* ``dfhack.items.getContainedItems(item)`` + + Returns a list of items contained in this one. + +* ``dfhack.items.getHolderBuilding(item)`` + + Returns the holder building or *nil*. + +* ``dfhack.items.getHolderUnit(item)`` + + Returns the holder unit or *nil*. + +* ``dfhack.items.getPosition(item)`` + + Returns the true *x,y,z* of the item, or *nil* if invalid. You should generally + use this method instead of reading *item.pos* directly since that field only stores + the last position where the item was on the ground. + +* ``dfhack.items.getBookTitle(item)`` + + Returns the title of the "book" item, or an empty string if the item isn't a "book" + or it doesn't have a title. A "book" is a codex or a tool item that has page or + writing improvements, such as scrolls and quires. + +* ``dfhack.items.getDescription(item, type[, decorate])`` + + Returns the string description of the item, as produced by the ``getItemDescription`` + method. A ``type`` of ``0`` results in a string like ``prickle berries [2]``. ``1`` + results in the singular ``prickle berry``, and ``2`` results in the plural + ``prickle berries``. If decorate is *true*, also adds markings for quality and + improvements, as well as ``(foreign)`` indicator (when applicable). + +* ``dfhack.items.getReadableDescription(item)`` + + Returns a string generally fit to usefully describe the item to the player. + When the item description appears anywhere in a script output or in the UI, + this is usually the string you should use. + +* ``dfhack.items.moveToGround(item,pos)`` + + Move the item to the ground at position. Returns *false* if impossible. + +* ``dfhack.items.moveToContainer(item,container)`` + + Move the item to the container. Returns *false* if impossible. + +* ``dfhack.items.moveToBuilding(item,building[,use_mode[,force_in_building])`` + + Move the item to the building. Returns *false* if impossible. + ``use_mode`` defaults to ``df.building_item_role_type.TEMP``. + If set to ``df.building_item_role_type.PERM``, the item will be treated as part + of the building. If ``force_in_building`` is true, the item will be considered + to be stored by the building (used for items temporarily used in traps in + vanilla DF). + +* ``dfhack.items.moveToInventory(item,unit[,use_mode[,body_part]])`` + + Move the item to the unit inventory. Returns *false* if impossible. + ``use_mode`` defaults to ``df.inv_item_role_type.Hauled``. + ``body_part`` defaults to ``-1``. + +* ``dfhack.items.remove(item[,no_uncat])`` + + Cancels any jobs associated with the item, removes the item from containers + and inventories, hides the item from the UI, and, unless ``no_uncat`` is + true, marks it for garbage collection. + +* ``dfhack.items.makeProjectile(item)`` + + Turns the item into a projectile, and returns the new object, or *nil* + if impossible. + +* ``dfhack.items.getItemBaseValue(item_type, subtype, material, mat_index)`` + + Calculates the base value for an item of the specified type and material. + +* ``dfhack.items.getValue(item[,caravan_state])`` + + Calculates the value of an item. If a ``df.caravan_state`` object is given + (from ``df.global.plotinfo.caravans`` or + ``df.global.game.main_interface.trade.mer``), then the value is modified by civ + properties and any trade agreements that might be in effect. + +* ``dfhack.items.createItem(unit, item_type, item_subtype, mat_type, mat_index, no_floor)`` + + Creates an item, similar to the `createitem` plugin. Returns a list of created + ``df.item`` objects. + +* ``dfhack.items.checkMandates(item)`` + + Returns true if the item is free from mandates, or false if mandates prevent + trading the item. + +* ``dfhack.items.canTrade(item)`` + + Checks whether the item can be traded. + +* ``dfhack.items.canTradeWithContents(item)`` + + Returns false if the item or any contained items cannot be traded. + +* ``canTradeAnyWithContents(item)`` + + Returns true if the item is empty and can be traded or if the item contains + any item that can be traded. + +* ``dfhack.items.markForTrade(item, depot)`` + + Marks the given item for trade at the given depot. + +* ``dfhack.items.isRequestedTradeGood(item[,caravan_state])`` + + Returns whether a caravan will pay extra for the given item. If caravan_state + is not given, checks all active caravans. + +* ``dfhack.items.canMelt(item[,game_ui])`` + + Returns true if the item can be melted (at a smelter). Unless ``game_ui`` is + given and true, bars, non-empty metal containers, and items in unit + inventories are not considered meltable, even though they can be designated + for melting using the game UI. + +* ``dfhack.items.markForMelting(item)`` + + Marks the given item for melting, unless already marked. Returns true if the + melting status was changed. + +* ``dfhack.items.cancelMelting(item)`` + + Removes melting designation, if present, from the given item. Returns true if + the melting status was changed. + +* ``dfhack.items.isRouteVehicle(item)`` + + Checks whether the item is an assigned hauling vehicle. + +* ``dfhack.items.isSquadEquipment(item)`` + + Checks whether the item is assigned to a squad. + +* ``dfhack.items.getCapacity(item)`` + + Returns the capacity volume of an item that can serve as a container for + other items. Return value will be ``0`` for items that cannot serve as a + container. + +.. _lua-world: + +World module +------------ + +* ``dfhack.world.ReadPauseState()`` + + Returns *true* if the game is paused. + +* ``dfhack.world.SetPauseState(paused)`` + + Sets the pause state of the game. + +* ``dfhack.world.ReadCurrentYear()`` + + Returns the current game year. + +* ``dfhack.world.ReadCurrentTick()`` + + Returns the number of game ticks (``df.global.world.frame_counter``) since the + start of the current game year. + +* ``dfhack.world.ReadCurrentMonth()`` + + Returns the current game month, ranging from 0-11. The Dwarven year has 12 months. + +* ``dfhack.world.ReadCurrentDay()`` + + Returns the current game day, ranging from 1-28. Each Dwarven month has 28 days. + +* ``dfhack.world.ReadCurrentWeather()`` + + Returns the current game weather (``df.weather_type``). + +* ``dfhack.world.SetCurrentWeather(weather)`` + + Sets the current game weather to ``weather``. + +* ``dfhack.world.ReadWorldFolder()`` + + Returns the name of the directory/folder the current saved game is under, or an + empty string if no game was loaded this session. + +* ``dfhack.world.isFortressMode([gametype])`` +* ``dfhack.world.isAdventureMode([gametype])`` +* ``dfhack.world.isArena([gametype])`` +* ``dfhack.world.isLegends([gametype])`` + + Without any arguments, returns *true* if the current gametype matches. + Optionally accepts a ``gametype`` id to match against. + +* ``dfhack.world.getCurrentSite()`` + + Returns the currently loaded ``df.world_site`` or ``nil`` if no site is loaded. + +* ``dfhack.world.getAdventurer()`` + + Returns the current adventurer unit (if in adventure mode). + +.. _lua-maps: + +Maps module +----------- + +* ``dfhack.maps.getSize()`` + + Returns map size in blocks: *x, y, z* + +* ``dfhack.maps.getTileSize()`` + + Returns map size in tiles: *x, y, z* + +* ``dfhack.maps.getBlock(x,y,z)`` + + Returns a map block object for given x,y,z in local block coordinates. + +* ``dfhack.maps.isValidTilePos(coords)``, or ``isValidTilePos(x,y,z)`` + + Checks if the given df::coord or x,y,z in local tile coordinates are valid. + +* ``dfhack.maps.isTileVisible(coords)``, or ``isTileVisible(x,y,z)`` + + Checks if the given df::coord or x,y,z in local tile coordinates is visible. + +* ``dfhack.maps.getTileBlock(coords)``, or ``getTileBlock(x,y,z)`` + + Returns a map block object for given df::coord or x,y,z in local + tile coordinates. + +* ``dfhack.maps.ensureTileBlock(coords)``, or ``ensureTileBlock(x,y,z)`` + + Like ``getTileBlock``, but if the block is not allocated, try creating it. + +* ``dfhack.maps.getTileType(coords)``, or ``getTileType(x,y,z)`` + + Returns the tile type at the given coordinates, or *nil* if invalid. + +* ``dfhack.maps.getTileFlags(coords)``, or ``getTileFlags(x,y,z)`` + + Returns designation and occupancy references for the given coordinates, or + *nil, nil* if invalid. + +* ``dfhack.maps.getRegionBiome(region_coord2d)``, or ``getRegionBiome(x,y)`` + + Returns the biome info struct for the given global map region. + + ``dfhack.maps.getBiomeType(region_coord2d)`` or ``getBiomeType(x,y)`` + + Returns the biome_type for the given global map region. + +* ``dfhack.maps.enableBlockUpdates(block[,flow[,temperature]])`` + + Enables updates for liquid flow or temperature, unless already active. + +* ``dfhack.maps.spawnFlow(pos,type,mat_type,mat_index,dimension)`` + + Spawns a new flow (i.e., steam/mist/dust/etc) at the given pos, and with + the given parameters. Returns it, or *nil* if unsuccessful. + +* ``dfhack.maps.getGlobalInitFeature(index)`` + + Returns the global feature object with the given index. + +* ``dfhack.maps.getLocalInitFeature(region_coord2d,index)`` + + Returns the local feature object with the given region coords and index. + +* ``dfhack.maps.getTileBiomeRgn(coords)``, or ``getTileBiomeRgn(x,y,z)`` + + Returns *x, y* for use with ``getRegionBiome`` and ``getBiomeType``. + +* ``dfhack.maps.getPlantAtTile(pos)``, or ``getPlantAtTile(x,y,z)`` + + Returns the plant struct that owns the tile at the specified position. + +* ``dfhack.maps.getWalkableGroup(pos)`` + + Returns the walkability group for the given tile position. A return value + of ``0`` indicates that the tile is not walkable. The data comes from a + pathfinding cache maintained by DF. + + .. note:: + This cache is only updated when the game is unpaused, and thus + can get out of date if doors are forbidden or unforbidden, or + tools like `liquids` or `tiletypes` are used. It also cannot possibly + take into account anything that depends on the actual units, like + burrows, or the presence of invaders. + +* ``dfhack.maps.canWalkBetween(pos1, pos2)`` + + Checks if both positions are walkable and also share a walkability group. + +* ``dfhack.maps.hasTileAssignment(tilemask)`` + + Checks if the tile_bitmask object is not *nil* and contains any set bits. + Returns *true* or *false*. + +* ``dfhack.maps.getTileAssignment(tilemask,x,y)`` + + Checks if the tile_bitmask object is not *nil* and has the relevant bit set. + Returns *true* or *false*. + +* ``dfhack.maps.setTileAssignment(tilemask,x,y,enable)`` + + Sets the relevant bit in the tile_bitmask object to the *enable* argument. + +* ``dfhack.maps.resetTileAssignment(tilemask[,enable])`` + + Sets all bits in the mask to the *enable* argument. + +* ``dfhack.maps.isTileAquifer(pos)``, or ``isTileAquifer(x,y,z)`` + + Checks if there's an aquifer on the given tile position. + Returns *true* or *false*. + +* ``dfhack.maps.isTileHeavyAquifer(pos)``, or ``isTileHeavyAquifer(x,y,z)`` + + Checks if there's a heavy aquifer on the given tile position. + Returns *true* or *false*. + +* ``dfhack.maps.setTileAquifer(pos[,heavy])``, or ``setTileAquifer(x,y,z[,heavy])`` + + Adds a light aquifer on the given tile position, or a heavy aquifer if the + *heavy* argument is *true*. Returns *true* or *false* depending on success. + +* ``dfhack.maps.removeTileAquifer(pos)``, or ``removeTileAquifer(x,y,z)`` + + Removes an aquifer from the given tile position. + Returns *true* or *false* depending on success. + +* ``dfhack.maps.addMaterialSpatter(pos, mat, matg, state, amount)`` + + Adds a material spatter to the specified map tile. If the tile is already + full of that spatter, returns the amount left over. + + Specifying a state of -1 (None) will automatically choose either Solid, + Liquid, or Gas based on the material properties and the tile temperature. + +* ``dfhack.maps.addItemSpatter(pos, i_type, i_subtype, subcat1, subcat2, print_variant, amount)`` + + Adds an item spatter to the specified map tile. If the tile is already + full of that spatter, returns the amount left over. + + For plant growths, specifying a print_variant of -1 will automatically + choose an appropriate value. For other item types, this field is ignored. + +Burrows module +-------------- + +* ``dfhack.burrows.getName(burrow)`` + + Returns the name of the burrow. + If the burrow has no set name, returns the same placeholder name that DF would show in the UI. + +* ``dfhack.burrows.findByName(name[, ignore_final_plus])`` + + Returns the burrow pointer or *nil*. if ``ignore_final_plus`` is ``true``, + then ``+`` characters at the end of the names are ignored, both for the + specified ``name`` and the names of the burrows that it matches against. + +* ``dfhack.burrows.clearUnits(burrow)`` + + Removes all units from the burrow. + +* ``dfhack.burrows.isAssignedUnit(burrow,unit)`` + + Checks if the unit is in the burrow. + +* ``dfhack.burrows.setAssignedUnit(burrow,unit,enable)`` + + Adds or removes the unit from the burrow. + +* ``dfhack.burrows.clearTiles(burrow)`` + + Removes all tiles from the burrow. + +* ``dfhack.burrows.listBlocks(burrow)`` + + Returns a table of map block pointers. + +* ``dfhack.burrows.isAssignedTile(burrow,tile_coord)`` + + Checks if the tile is in burrow. + +* ``dfhack.burrows.setAssignedTile(burrow,tile_coord,enable)`` + + Adds or removes the tile from the burrow. + Returns *false* if invalid coords. + +* ``dfhack.burrows.isAssignedBlockTile(burrow,block,x,y)`` + + Checks if the tile within the block is in burrow. + +* ``dfhack.burrows.setAssignedBlockTile(burrow,block,x,y,enable)`` + + Adds or removes the tile from the burrow. + Returns *false* if invalid coords. + +Buildings module +---------------- + +General +~~~~~~~ + +* ``dfhack.buildings.getGeneralRef(building, type)`` + + Searches for a general_ref with the given type. + +* ``dfhack.buildings.getSpecificRef(building, type)`` + + Searches for a specific_ref with the given type. + +* ``dfhack.buildings.getOwner(civzone)`` + + Returns the owner of the zone or *nil* if there isn't one. + +* ``dfhack.buildings.setOwner(civzone,unit)`` + + Replaces the owner of the civzone. If unit is *nil*, removes ownership. + Returns *false* in case of error. + + ``dfhack.buildings.getName(building)`` + + Returns the name of the building as it would appear in game. + +* ``dfhack.buildings.getSize(building)`` + + Returns *width, height, centerx, centery*. + +* ``dfhack.buildings.findAtTile(pos)``, or ``findAtTile(x,y,z)`` + + Scans the buildings for the one located at the given tile. + Does not work on civzones. Warning: linear scan if the map + tile indicates there are buildings at it. + +* ``dfhack.buildings.findCivzonesAt(pos)``, or ``findCivzonesAt(x,y,z)`` + + Scans civzones, and returns a lua sequence of those that touch + the given tile, or *nil* if none. + +* ``dfhack.buildings.getCorrectSize(width, height, type, subtype, custom, direction)`` + + Computes correct dimensions for the specified building type and orientation, + using width and height for flexible dimensions. + Returns *is_flexible, width, height, center_x, center_y*. + +* ``dfhack.buildings.checkFreeTiles(pos,size[,bld[,change_extents[,allow_occupied[,allow_wall[,allow_flow]]]]])`` + + Checks if the rectangle defined by ``pos`` and ``size``, and possibly the + extents associated with bld, can be used for placing a building. If + ``change_extents`` is true, bad tiles are removed from extents. If + ``allow_occupied``, the occupancy test is skipped. Set ``allow_wall`` to true + if the building is unhindered by walls (such as an activity zone). Set + ``allow_flow`` to true if the building can be built even if there is deep + water or any magma on the tile (such as abstract buildings). + +* ``dfhack.buildings.countExtentTiles(extents,defval)`` + + Returns the number of tiles included by extents, or defval. + +* ``dfhack.buildings.containsTile(building, x, y)`` + + Checks if the building contains the specified tile. If the building contains + extents, then the extents are checked. Otherwise, returns whether the x and y + map coordinates are within the building's bounding box. + +* ``dfhack.buildings.hasSupport(pos,size)`` + + Checks if a bridge constructed at specified position would have + support from terrain, and thus won't collapse if retracted. + +* ``dfhack.buildings.getStockpileContents(stockpile)`` + + Returns a list of items stored on the given stockpile. + Ignores empty bins, barrels, and wheelbarrows assigned as storage and + transport for that stockpile. + +* ``dfhack.buildings.getCageOccupants(cage)`` + + Returns a list of units in the given built cage. Note that this is different + from the list of units assigned to the cage, which can be accessed with + ``cage.assigned_units``. + +Low-level +~~~~~~~~~ +Low-level building creation functions: + +* ``dfhack.buildings.allocInstance(pos, type, subtype, custom)`` + + Creates a new building instance of given type, subtype and custom type, + at specified position. Returns the object, or *nil* in case of an error. + +* ``dfhack.buildings.setSize(building, width, height, direction)`` + + Configures an object returned by ``allocInstance``, using specified + parameters wherever appropriate. If the building has fixed size along + any dimension, the corresponding input parameter will be ignored. + Returns *false* if the building cannot be placed, or *true, width, + height, rect_area, true_area*. Returned width and height are the + final values used by the building; true_area is less than rect_area + if any tiles were removed from designation. You can specify a non-rectangular + designation for building types that support extents by setting the + ``room.extents`` bitmap before calling this function. The extents will be + reset, however, if the size returned by this function doesn't match the + input size parameter. + +* ``dfhack.buildings.constructAbstract(building)`` + + Links a fully configured object created by ``allocInstance`` into the + world. The object must be an abstract building, i.e., a stockpile or civzone. + Returns *true*, or *false* if impossible. + +* ``dfhack.buildings.constructWithItems(building, items)`` + + Links a fully configured object created by ``allocInstance`` into the + world for construction, using a list of specific items as material. + Returns *true*, or *false* if impossible. + +* ``dfhack.buildings.constructWithFilters(building, job_items)`` + + Links a fully configured object created by ``allocInstance`` into the + world for construction, using a list of job_item filters as inputs. + Returns *true*, or *false* if impossible. Filter objects are claimed + and possibly destroyed in any case. + Use a negative ``quantity`` field value to auto-compute the amount + from the size of the building. + +* ``dfhack.buildings.deconstruct(building)`` + + Destroys the building, or queues a deconstruction job. + Returns *true* if the building was destroyed and deallocated immediately. + +* ``dfhack.buildings.notifyCivzoneModified(building)`` + + Rebuilds the civzone <-> overlapping building association mapping. + Call after changing extents or modifying size in some fashion + +* ``dfhack.buildings.markedForRemoval(building)`` + + Returns *true* if the building is marked for removal (with :kbd:`x`), *false* + otherwise. + +* ``dfhack.buildings.getRoomDescription(building[, unit])`` + + If the building is a room, returns a description including quality modifiers, + e.g., "Royal Bedroom". Otherwise, returns an empty string. + + The unit argument is passed through to DF and may modify the room's value + depending on the unit given. + +* ``dfhack.buildings.completeBuild(building)`` + + Complete an unconstructed or partially-constructed building and link it into + the world. + +High-level +~~~~~~~~~~ +More high-level functions are implemented in lua and can be loaded by +``require('dfhack.buildings')``. See ``hack/lua/dfhack/buildings.lua``. + +Among them are: + +* ``dfhack.buildings.getFiltersByType(argtable,type,subtype,custom)`` + + Returns a sequence of lua structures, describing input item filters + suitable for the specified building type, or *nil* if unknown or invalid. + The returned sequence is suitable for use as the ``job_items`` argument + of ``constructWithFilters``. + Uses tables defined in ``buildings.lua``. + + Argtable members ``material`` (the default name), ``bucket``, ``barrel``, + ``chain``, ``mechanism``, ``screw``, ``pipe``, ``anvil``, ``weapon`` are used + to augment the basic attributes with more detailed information if the + building has input items with the matching name (see the tables for naming + details). Note that it is impossible to *override* any properties this way, + only supply those that are not mentioned otherwise. One exception is that + ``flags2.non_economic`` is automatically cleared if an explicit material + is specified. + +* ``dfhack.buildings.constructBuilding{...}`` + + Creates a building in one call, using options contained + in the argument table. Returns the building, or *nil, error*. + + .. note:: + Despite the name, unless the building is abstract, + the function creates it in an 'unconstructed' stage, with + a queued in-game job that will actually construct it. I.e., + the function replicates programmatically what can be done + through the construct building menu in the game ui, except + that it does less environment constraint checking. + + The following options can be used: + + - ``pos = coordinates``, or ``x = ..., y = ..., z = ...`` + + Mandatory. Specifies the left upper corner of the building. + + - ``type = df.building_type.FOO, subtype = ..., custom = ...`` + + Mandatory. Specifies the type of the building. Obviously, subtype + and custom are only expected if the type requires them. + + - ``fields = { ... }`` + + Initializes fields of the building object after creation with + ``df.assign``. If ``room.extents`` is assigned this way and this function + returns with error, the memory allocated for the extents is freed. + + - ``width = ..., height = ..., direction = ...`` + + Sets size and orientation of the building. If it is + fixed-size, specified dimensions are ignored. + + - ``full_rectangle = true`` + + For buildings like stockpiles or farm plots that can normally + accommodate individual tile exclusion, forces an error if any + tiles within the specified width*height are obstructed. + + - ``items = { item, item ... }``, or ``filters = { {...}, {...}... }`` + + Specifies explicit items or item filters to use in construction. + It is the job of the user to ensure they are correct for the building type. + + - ``abstract = true`` + + Specifies that the building is abstract and does not require construction. + Required for stockpiles and civzones; an error otherwise. + + - ``material = {...}, mechanism = {...}, ...`` + + If none of ``items``, ``filter``, or ``abstract`` is used, + the function uses ``getFiltersByType`` to compute the input + item filters, and passes the argument table through. If no filters + can be determined this way, ``constructBuilding`` throws an error. + + +Constructions module +-------------------- + +* ``dfhack.constructions.designateNew(pos,type,item_type,mat_index)`` + + Designates a new construction at given position. If there already is + a planned but not completed construction there, changes its type. + Returns *true*, or *false* if obstructed. + Note that designated constructions are technically buildings. + +* ``dfhack.constructions.designateRemove(pos)``, or ``designateRemove(x,y,z)`` + + If there is a construction or a planned construction at the specified + coordinates, designates it for removal, or instantly cancels the planned one. + Returns *true, was_only_planned* if removed; or *false* if none found. + +* ``dfhack.constructions.findAtTile(pos)``, or ``findAtTile(x,y,z)`` + + Returns the construction at the given position, or ``nil`` if there isn't one. + +* ``dfhack.constructions.insert(construction)`` + + Properly inserts the given construction into the game. Returns false and fails + to insert if there was already a construction at the position. + +Kitchen module +-------------- + +* ``dfhack.kitchen.findExclusion(type, item_type, item_subtype, mat_type, mat_index)`` + + Finds a kitchen exclusion in the vectors in ``df.global.ui.kitchen``. Returns + -1 if not found. + + * ``type`` is a ``df.kitchen_exc_type`` with exactly one flag set, i.e + ``{Cook=true}`` or ``{Brew=true}``. + * ``item_type`` is a ``df.item_type`` + * ``item_subtype``, ``mat_type``, and ``mat_index`` are all numeric + +* ``dfhack.kitchen.addExclusion(type, item_type, item_subtype, mat_type, mat_index)`` +* ``dfhack.kitchen.removeExclusion(type, item_type, item_subtype, mat_type, mat_index)`` + + Adds or removes a kitchen exclusion, using the same parameters as + ``findExclusion``. Both return ``true`` on success and ``false`` on failure, + e.g., when adding an exclusion that already exists or removing one that does + not. + +Screen API +---------- + +The screen module implements support for drawing to the tiled screen of the game. +Note that drawing only has any effect when done from callbacks, so it can only +be feasibly used in the `core context `. + +.. contents:: + :local: + +Basic painting functions +~~~~~~~~~~~~~~~~~~~~~~~~ + +Common parameters to these functions include: + +* ``x``, ``y``: screen coordinates in tiles; the upper left corner of the screen + is ``x = 0, y = 0`` +* ``pen``: a `pen object ` +* ``map``: a boolean (defaults to false) indicating whether to draw to a + separate map buffer. The Steam version uses separate map buffers with square + tiles for for all types of maps (i.e. fort, region, and world). + +Functions: + +* ``dfhack.screen.getWindowSize()`` + + Returns *width, height* of the screen. + +* ``dfhack.screen.getMousePos()`` + + Returns *x,y* of the UI interface tile the mouse is over, with the upper left + corner being ``0,0``. To get the map tile coordinate that the mouse is over, + see ``dfhack.gui.getMousePos()``. + +* ``dfhack.screen.getMousePixels()`` + + Returns *x,y* of the screen coordinates the mouse is over in pixels, with the + upper left corner being ``0,0``. + +* ``dfhack.screen.inGraphicsMode()`` + + Checks if [GRAPHICS:YES] was specified in init. + +* ``dfhack.screen.paintTile(pen,x,y[,char[,tile[,map]]])`` + + Paints a tile using given parameters. `See below ` for a + description of ``pen``. The map argument is only supported for local maps + (i.e. fort mode and adventure mode outside of fast travel). The ``char`` and + ``tile`` arguments allow overriding the respective parts of the ``pen`` + without constructing a new pen beforehand. + + Returns *false* on error, e.g., if coordinates are out of bounds + +* ``dfhack.screen.paintMapPortTile(pen,x,y[,char[,tile]])`` + + Paints a tile using given parameters onto the interface texpos layer of a map + port (e.g., the world map or the zoomed-in map for embark selection). The + ``char`` and ``tile`` arguments work as above. + +* ``dfhack.screen.readTile(x,y[,map])`` + + Retrieves the contents of the specified tile from the screen buffers. + Returns a `pen object `, or *nil* if invalid or TrueType. + +* ``dfhack.screen.readMapPortTile(x,y)`` + + Retrieves the contents of the specified tile from the screen buffers. Returns + a `pen object `, or *nil* if invalid. + + For now only looks at the ``sites`` textpos layer. + +* ``dfhack.screen.paintString(pen,x,y,text[,map])`` + + Paints the string starting at *x,y*. Uses the string characters + in sequence to override the ``ch`` field of `pen `. + + Returns *true* if painting at least one character succeeded. + +* ``dfhack.screen.fillRect(pen,x1,y1,x2,y2[,map])`` + + Fills the rectangle specified by the coordinates with the given + `pen `. Returns *true* if painting at least one + character succeeded. + +* ``dfhack.screen.findGraphicsTile(pagename,x,y)`` + + Finds a tile from a graphics set (i.e., the raws used for creatures), + if in graphics mode and loaded. + + Returns: *tile, tile_grayscale*, or *nil* if not found. + The values can then be used for the *tile* field of *pen* structures. + +* ``dfhack.screen.hideGuard(screen,callback[,args...])`` + + Removes screen from the viewscreen stack, calls the callback + (with optional supplied arguments), and then restores the screen on + the top of the viewscreen stack. + +* ``dfhack.screen.clear()`` + + Fills the screen with blank background. + +* ``dfhack.screen.invalidate()`` + + Requests repaint of the screen by setting a flag. Unlike other + functions in this section, this may be used at any time. + +* ``dfhack.screen.getKeyDisplay(key)`` + + Returns the string that should be used to represent the given + logical keybinding on the screen in texts like "press Key to ...". + +* ``dfhack.screen.keyToChar(key)`` + + Returns the integer character code of the string input + character represented by the given logical keybinding, + or *nil* if not a string input key. + +* ``dfhack.screen.charToKey(charcode)`` + + Returns the keybinding representing the given string input + character, or *nil* if impossible. + +.. _lua-screen-pen: + +Pen API +~~~~~~~ + +The ``pen`` argument used by ``dfhack.screen`` functions may be represented +by a table with the following possible fields: + + ``ch`` + Provides the ordinary tile character, as either a 1-character string or a number. + Can be overridden with the ``char`` function parameter. + ``fg`` + Foreground color for the ordinary tile. Defaults to COLOR_GREY (7). + ``bg`` + Background color for the ordinary tile. Defaults to COLOR_BLACK (0). + ``bold`` + Bright/bold text flag. If *nil*, computed based on (fg & 8); fg is masked to 3 bits. + Otherwise should be *true/false*. + ``tile`` + Graphical tile id. Ignored unless [GRAPHICS:YES] was in init.txt. + ``tile_color = true`` + Specifies that the tile should be shaded with *fg/bg*. + ``tile_fg, tile_bg`` + If specified, overrides *tile_color* and supplies shading colors directly. + ``keep_lower`` + If set to true, will not overwrite the background tile when filling in + the foreground tile. + ``write_to_lower`` + If set to true, the specified ``tile`` will be written to the background + instead of the foreground. + ``top_of_text`` + If set to true, the specified ``tile`` will have the top half of the specified + ``ch`` character superimposed over the lower half of the tile. + ``bottom_of_text`` + If set to true, the specified ``tile`` will have the bottom half of the specified + ``ch`` character superimposed over the top half of the tile. + +Alternatively, it may be a pre-parsed native object with the following API: + +* ``dfhack.pen.make(base[,pen_or_fg[,bg[,bold]]])`` + + Creates a new pre-parsed pen by combining its arguments according to the + following rules: + + 1. The ``base`` argument may be a pen object, a pen table as specified above, + or a single color value. In the single value case, it is split into + ``fg`` and ``bold`` properties, and others are initialized to 0. + This argument will be converted to a pre-parsed object and returned + if there are no other arguments. + + 2. If the ``pen_or_fg`` argument is specified as a table or object, it + completely replaces the base, and is returned instead of it. + + 3. Otherwise, the non-nil subset of the optional arguments is used + to update the ``fg``, ``bg`` and ``bold`` properties of the base. + If the ``bold`` flag is *nil*, but *pen_or_fg* is a number, ``bold`` + is deduced from it like in the simple base case. + + This function always returns a new pre-parsed pen, or *nil*. + +* ``dfhack.pen.parse(base[,pen_or_fg[,bg[,bold]]])`` + + Exactly like the above function, but returns ``base`` or ``pen_or_fg`` + directly if they are already a pre-parsed native object. + +* ``pen.property``, ``pen.property = value``, ``pairs(pen)`` + + Pre-parsed pens support reading and setting their properties, + but don't behave exactly like a simple table would; for instance, + assigning to ``pen.tile_color`` also resets ``pen.tile_fg`` and + ``pen.tile_bg`` to *nil*. + +Screen management +~~~~~~~~~~~~~~~~~ + +In order to actually be able to paint to the screen, it is necessary +to create and register a viewscreen (basically a modal dialog) with +the game. + +.. warning:: + As a matter of policy, in order to avoid user confusion, all + interface screens added by dfhack should bear the "DFHack" signature. + +Screens are managed with the following functions: + +* ``dfhack.screen.show(screen[,below])`` + + Displays the given screen, possibly placing it below a different one. + The screen must not be already shown. Returns *true* if success. + +* ``dfhack.screen.dismiss(screen[,to_first])`` + + Marks the screen to be removed when the game enters its event loop. + If ``to_first`` is *true*, all screens up to the first one will be deleted. + +* ``dfhack.screen.isDismissed(screen)`` + + Checks if the screen is already marked for removal. + +Apart from a native viewscreen object, these functions accept a table +as a screen. In this case, ``show`` creates a new native viewscreen +that delegates all processing to methods stored in that table. + +.. note:: + + * The `gui.Screen class ` provides stubs for all of the + functions listed below, and its use is recommended + * Lua-implemented screens are only supported in the `core context `. + +Supported callbacks and fields are: + +* ``screen._native`` + + Initialized by ``show`` with a reference to the backing viewscreen + object, and removed again when the object is deleted. + +* ``function screen:onShow()`` + + Called by ``dfhack.screen.show`` if successful. + +* ``function screen:onDismiss()`` + + Called by ``dfhack.screen.dismiss`` if successful. + +* ``function screen:onDestroy()`` + + Called from the destructor when the viewscreen is deleted. + +* ``function screen:onResize(w, h)`` + + Called before ``onRender`` or ``onIdle`` when the window size has changed. + +* ``function screen:onRender()`` + + Called when the viewscreen should paint itself. This is the only context + where the above painting functions work correctly. + + If omitted, the screen is cleared; otherwise it should do that itself. + In order to make a dialog where portions of the parent viewscreen are still + visible in the background, call ``screen:renderParent()``. + + If artifacts are left on the parent even after this function is called, such + as when the window is dragged or is resized, any code can set + ``gui.Screen.request_full_screen_refresh`` to ``true``. Then when + ``screen.renderParent()`` is next called, it will do a full flush of the + graphics and clear the screen of artifacts. + +* ``function screen:onIdle()`` + + Called every frame when the screen is on top of the stack. + +* ``function screen:onHelp()`` + + Called when the help keybinding is activated (usually '?'). + +* ``function screen:onInput(keys)`` + + Called when keyboard or mouse events are available. + If any keys are pressed, the keys argument is a table mapping them to *true*. + Note that this refers to logical keybindings computed from real keys via + options; if multiple interpretations exist, the table will contain multiple keys. + + The table also may contain special keys: + + ``_STRING`` + Maps to an integer in range 0-255. Duplicates a separate "STRING_A???" code + for convenience. + + ``_MOUSE_L, _MOUSE_R, _MOUSE_M`` + If the left, right, and/or middle mouse button was just pressed. + + ``_MOUSE_L_DOWN, _MOUSE_R_DOWN, _MOUSE_M_DOWN`` + If the left, right, and/or middle mouse button is being held down. + + If this method is omitted, the screen is dismissed on reception of the + ``LEAVESCREEN`` key. + +* ``function screen:onGetSelectedUnit()`` +* ``function screen:onGetSelectedItem()`` +* ``function screen:onGetSelectedJob()`` +* ``function screen:onGetSelectedBuilding()`` +* ``function screen:onGetSelectedStockpile()`` +* ``function screen:onGetSelectedCivZone()`` +* ``function screen:onGetSelectedPlant()`` + + Override these if you want to provide a custom return value for the matching + ``dfhack.gui.getSelected...`` function. + + +PenArray class +-------------- + +Screens that require significant computation in their onRender() method can use +a ``dfhack.penarray`` instance to cache their output. + +* ``dfhack.penarray.new(w, h)`` + + Creates a new penarray instance with an internal buffer of ``w * h`` tiles. + These dimensions currently cannot be changed after a penarray is instantiated. + +* ``penarray:clear()`` + + Clears the internal buffer, similar to ``dfhack.screen.clear()``. + +* ``penarray:get_dims()`` + + Returns the x and y dimensions of the internal buffer. + +* ``penarray:get_tile(x, y)`` + + Returns a pen corresponding to the tile at (``x``, ``y``) in the internal buffer. + Note that indices are 0-based. + +* ``penarray:set_tile(x, y, pen)`` + + Sets the tile at (``x``, ``y``) in the internal buffer to the pen given. + +* ``penarray:draw(x, y, w, h, bufferx, buffery)`` + + Draws the contents of the internal buffer, beginning at + (``bufferx``, ``buffery``) and spanning ``w`` columns and ``h`` rows, to the + screen starting at (``x``, ``y``). Any invalid screen and buffer coordinates + are skipped. + + ``bufferx`` and ``buffery`` default to 0. + + +Textures module +--------------- + +In order for the game to render a particular tile (graphic), it needs to know the +``texpos`` - the position in the vector of the registered game textures (also the +graphical tile id passed as the ``tile`` field in a `Pen `). +Adding new textures to the vector is not difficult, but the game periodically +deletes textures that are in the vector, and that's a problem since it +invalidates the ``texpos`` value that used to point to that texture. +The ``textures`` module solves this problem by providing a stable handle instead of a +raw ``texpos``. When we need to draw a particular tile, we can look up the current +``texpos`` value via the handle. +Texture module can register textures in two ways: to reserved and dynamic ranges. +Reserved range is a limit buffer in a game texture vector, that will never be wiped. +It is good for static assets, which need to be loaded at the very beginning and will +be used during the process running. In other cases, it is better to use dynamic range. +If reserved range buffer limit has been reached, dynamic range will be used by default. + +* ``loadTileset(file, tile_px_w, tile_px_h[, reserved])`` + + Loads a tileset from the image ``file`` with give tile dimensions in pixels. The + image will be sliced in row major order. Returns an array of ``TexposHandle``. + ``reserved`` is optional boolean argument, which indicates texpos range. + ``true`` - reserved, ``false`` - dynamic (default). + + Example usage:: + + local logo_textures = dfhack.textures.loadTileset('hack/data/art/dfhack.png', 8, 12) + local first_texposhandle = logo_textures[1] + +* ``getTexposByHandle(handle)`` + + Get the current ``texpos`` for the given ``TexposHandle``. Always use this method to + get the ``texpos`` for your texture. ``texpos`` can change when game textures are + reset, but the handle will be the same. + +* ``createTile(pixels, tile_px_w, tile_px_h[, reserved])`` + + Create and register a new texture with the given tile dimensions and an array of + ``pixels`` in row major order. Each pixel is an integer representing color in packed + RBGA format (for example, #0022FF11). Returns a ``TexposHandle``. + ``reserved`` is optional boolean argument, which indicates texpos range. + ``true`` - reserved, ``false`` - dynamic (default). + +* ``createTileset(pixels, texture_px_w, texture_px_h, tile_px_w, tile_px_h[, reserved])`` + + Create and register a new texture with the given texture dimensions and an array of + ``pixels`` in row major order. Then slice it into tiles with the given tile + dimensions. Each pixel is an integer representing color in packed RBGA format (for + example #0022FF11). Returns an array of ``TexposHandle``. + ``reserved`` is optional boolean argument, which indicates texpos range. + ``true`` - reserved, ``false`` - dynamic (default). + +* ``deleteHandle(handle)`` + + ``handle`` here can be single ``TexposHandle`` or an array of ``TexposHandle``. + Deletes all metadata and texture(s) related to the given handle(s). The handles + become invalid after this call. + + +Filesystem module +----------------- + +Most of these functions return ``true`` on success and ``false`` on failure, +unless otherwise noted. + +* ``dfhack.filesystem.exists(path)`` + + Returns ``true`` if ``path`` exists. + +* ``dfhack.filesystem.isfile(path)`` + + Returns ``true`` if ``path`` exists and is a file. + +* ``dfhack.filesystem.isdir(path)`` + + Returns ``true`` if ``path`` exists and is a directory. + +* ``dfhack.filesystem.getcwd()`` + + Returns the current working directory. To retrieve the DF path, use + ``dfhack.getDFPath()`` instead. + +* ``dfhack.filesystem.chdir(path)`` + + Changes the current directory to ``path``. Use with caution. + +* ``dfhack.filesystem.restore_cwd()`` + + Restores the current working directory to what it was when DF started. + +* ``dfhack.filesystem.get_initial_cwd()`` + + Returns the value of the working directory when DF was started. + +* ``dfhack.filesystem.mkdir(path)`` + + Creates a new directory. Returns ``false`` if unsuccessful, including if + ``path`` already exists. + +* ``dfhack.filesystem.mkdir_recursive(path)`` + + Creates a new directory, including any intermediate directories that + don't exist yet. Returns ``true`` if the folder was created or already + existed, or ``false`` if unsuccessful. + +* ``dfhack.filesystem.rmdir(path)`` + + Removes a directory. Only works if the directory is already empty. + +* ``dfhack.filesystem.mtime(path)`` + + Returns the modification time (in seconds) of the file or directory + specified by ``path``, or -1 if ``path`` does not exist. + This depends on the system clock and should only be used locally. + +* ``dfhack.filesystem.listdir(path)`` + + Lists files/directories in a directory. Returns ``{}`` if ``path`` does not exist. + +* ``dfhack.filesystem.listdir_recursive(path [, depth = 10[, include_prefix = true]])`` + + Lists all files/directories in a directory and its subdirectories. All + directories are listed before their contents. Returns a table with subtables + of the format: ``{path: 'path to file', isdir: true|false}`` + + Note that ``listdir()`` returns only the base name of each directory entry, + while ``listdir_recursive()`` returns the initial path and all components + following it for each entry. Set ``include_prefix`` to false if you don't + want the ``path`` string prepended to the returned filenames. + +* ``dfhack.filesystem.getBaseDir()`` + + Returns a directory to which DF (and thus DFHack) can save files. This will either + be DF's install directory, or the path returned by ``SDLGetPrefDir``, depending on whether + DF is in "portable mode" or not. + +* ``dfhack.filesystem.getInstallDir()`` + + Returns the the directory in which DF is installed. + +Console API +----------- + +* ``dfhack.console.clear()`` + + Clears the console; equivalent to the ``cls`` built-in command. + +* ``dfhack.console.flush()`` + + Flushes all output to the console. This can be useful when printing text that + does not end in a newline but should still be displayed. + +.. _lua-api-internal: + +Internal API +------------ + +These functions are intended for the use by dfhack developers, +and are only documented here for completeness: + +* ``dfhack.internal.getPE()`` + + Returns the PE timestamp of the DF executable (only on Windows) + +* ``dfhack.internal.getMD5()`` + + Returns the MD5 of the DF executable (only on OS X and Linux) + +* ``dfhack.internal.getAddress(name)`` + + Returns the global address ``name``, or *nil*. + +* ``dfhack.internal.setAddress(name, value)`` + + Sets the global address ``name``. Returns the value of ``getAddress`` + before the change. + +* ``dfhack.internal.getVTable(name)`` + + Returns the pre-extracted vtable address ``name``, or *nil*. + +* ``dfhack.internal.getImageBase()`` + + Returns the mmap base of the executable. + +* ``dfhack.internal.getRebaseDelta()`` + + Returns the ASLR rebase offset of the DF executable. + +* ``dfhack.internal.adjustOffset(offset[,to_file])`` + + Returns the re-aligned offset, or *nil* if invalid. + If ``to_file`` is true, the offset is adjusted from memory to file. + This function returns the original value everywhere except windows. + +* ``dfhack.internal.getMemRanges()`` + + Returns a sequence of tables describing virtual memory ranges of the process. + +* ``dfhack.internal.patchMemory(dest,src,count)`` + + Like memmove below, but works even if dest is read-only memory, e.g., code. + If destination overlaps a completely invalid memory region, or another error + occurs, returns false. + +* ``dfhack.internal.patchBytes(write_table[, verify_table])`` + + The first argument must be a lua table, which is interpreted as a mapping from + memory addresses to byte values that should be stored there. The second argument + may be a similar table of values that need to be checked before writing anything. + + The function takes care to either apply all of ``write_table``, or none of it. + An empty ``write_table`` with a nonempty ``verify_table`` can be used to reasonably + safely check if the memory contains certain values. + + Returns *true* if successful, or *nil, error_msg, address* if not. + +* ``dfhack.internal.memmove(dest,src,count)`` + + Wraps the standard memmove function. Accepts both numbers and refs as pointers. + +* ``dfhack.internal.memcmp(ptr1,ptr2,count)`` + + Wraps the standard memcmp function. + +* ``dfhack.internal.memscan(haystack,count,step,needle,nsize)`` + + Searches for ``needle`` of ``nsize`` bytes in ``haystack``, + using ``count`` steps of ``step`` bytes. + Returns: *step_idx, sum_idx, found_ptr*, or *nil* if not found. + +* ``dfhack.internal.diffscan(old_data, new_data, start_idx, end_idx, eltsize[, oldval[, newval[, delta]]])`` + + Searches for differences between buffers at ptr1 and ptr2, as integers of size eltsize. + The oldval, newval or delta arguments may be used to specify additional constraints. + Returns: *found_index*, or *nil* if end reached. + +* ``dfhack.internal.cxxDemangle(mangled_name)`` + + Decodes a mangled C++ symbol name. Returns the demangled name on success, or + ``nil, error_message`` on failure. + +* ``dfhack.internal.getDir(path)`` + + Lists files/directories in a directory. + Returns: *file_names* or empty table if not found. Identical to ``dfhack.filesystem.listdir(path)``. + +* ``dfhack.internal.strerror(errno)`` + + Wraps strerror() - returns a string describing a platform-specific error code + +* ``dfhack.internal.addScriptPath(path, search_before)`` + + Registers ``path`` as a `script path `. + If ``search_before`` is passed and ``true``, the path will be searched before + the default paths (e.g., ``dfhack-config/scripts``, ``hack/scripts``); otherwise, + it will be searched after. + + Returns ``true`` if successful or ``false`` otherwise (e.g., if the path does + not exist or has already been registered). + +* ``dfhack.internal.removeScriptPath(path)`` + + Removes ``path`` from the list of `script paths ` and returns + ``true`` if successful. + +* ``dfhack.internal.getScriptPaths()`` + + Returns the list of `script paths ` in the order they are + searched, including defaults. (This can change if a world is loaded.) + +* ``dfhack.internal.findScript(name)`` + + Searches `script paths ` for the script ``name`` (which + includes the ``.lua`` extension) and returns the absolute path of the first + file found, or ``nil`` on failure. Slashes in the path are canonicalized to + forward slashes. + + .. note:: + You can use the ``dfhack.findScript()`` wrapper if you want to specify the + script name without the ``.lua`` extension. + +* ``dfhack.internal.runCommand(command[, use_console])`` + + Runs a DFHack command with the core suspended. Used internally by the + ``dfhack.run_command()`` family of functions. + + - ``command``: either a table of strings or a single string which is parsed by + the default console tokenization strategy (not recommended) + - ``use_console``: if true, output is sent directly to the DFHack console + + Returns a table with a ``status`` key set to a ``command_result`` constant + (``status = CR_OK`` indicates success). Additionally, if ``use_console`` is + not true, enumerated table entries of the form ``{color, text}`` are included, + e.g., ``result[1][0]`` is the color of the first piece of text printed (a + ``COLOR_`` constant). These entries can be iterated over with ``ipairs()``. + +* ``dfhack.internal.md5(string)`` + + Returns the MD5 hash of the given string. + +* ``dfhack.internal.md5File(filename[,first_kb])`` + + Computes the MD5 hash of the given file. Returns ``hash, length`` on success + (where ``length`` is the number of bytes read from the file), or ``nil, + error`` on failure. + + If the parameter ``first_kb`` is specified and evaluates to ``true``, and the + hash was computed successfully, a table containing the first 1024 bytes of the + file is returned as the third return value. + +* ``dfhack.internal.threadid()`` + + Returns a numeric identifier of the current thread. + +* ``dfhack.internal.msizeAddress(address)`` + + Returns the allocation size of an address. + Does not require a heap snapshot. This function will crash on an invalid pointer. + Windows only. + +* ``dfhack.internal.getHeapState()`` + + Returns the state of the heap. 0 == ok or empty, 1 == heap bad ptr, 2 == heap bad begin, + 3 == heap bad node. Does not require a heap snapshot. This may be unsafe to use directly + from lua if the heap is corrupt. Windows only. + +* ``dfhack.internal.heapTakeSnapshot()`` + + Clears any existing heap snapshot, and takes an internal heap snapshot for later + consumption. Windows only. Returns the same values as getHeapState() + +* ``dfhack.internal.isAddressInHeap(address)`` + + Checks if an address is a member of the heap. It may be dangling. + Requires a heap snapshot. + +* ``dfhack.internal.isAddressActiveInHeap(address)`` + + Checks if an address is a member of the heap, and actively in use (i.e., valid). + Requires a heap snapshot. + +* ``dfhack.internal.isAddressUsedAfterFreeInHeap(address)`` + + Checks if an address is a member of the heap, but is not currently allocated + (i.e., use after free). Requires a heap snapshot. + Note that Windows eagerly removes freed pointers from the heap, + so this is unlikely to trigger. + +* ``dfhack.internal.getAddressSizeInHeap(address)`` + + Gets the allocated size of a member of the heap. Useful for detecting misaligns, + as this does not return block size. Requires a heap snapshot. + +* ``dfhack.internal.getRootAddressOfHeapObject(address)`` + + Gets the base heap allocation address of a address that lies internally within + a piece of allocated memory. E.g., if you have a heap allocated struct and call + this function on the address of the second member, it will return the address + of the struct. Returns 0 if the address is not found. Requires a heap snapshot. + +* ``dfhack.internal.getClipboardTextCp437()`` + + Gets the system clipboard text (and converts text to CP437 encoding). + +* ``dfhack.internal.setClipboardTextCp437(text)`` + + Sets the system clipboard text from a CP437 string. + +* ``dfhack.internal.getClipboardTextCp437Multiline()`` + + Gets the system clipboard text (and converts text to CP437 encoding). + Character 0x10 is interpreted as a newline instead of the usual CP437 glyph. + The text is returned as a list of strings, one for each line of text on the + clipboard. + +* ``dfhack.internal.setClipboardTextCp437Multiline(text)`` + + Sets the system clipboard text from a CP437 string. Character 0x10 is + interpreted as a newline instead of the usual CP437 glyph. + +* ``dfhack.internal.getModifiers()`` + + Returns the state of the keyboard modifier keys in a table of string -> + boolean. The keys are ``ctrl``, ``shift``, ``super``, and ``alt``. + +* ``dfhack.internal.getSuppressDuplicateKeyboardEvents()`` +* ``dfhack.internal.setSuppressDuplicateKeyboardEvents(suppress)`` + + Gets and sets the flag for whether to suppress DF key events when a DFHack + keybinding is matched and a command is launched. + +* ``dfhack.internal.setMortalMode(value)`` +* ``dfhack.internal.setArmokTools(tool_names)`` + + Used to sync mortal mode state to DFHack Core memory for use in keybinding + checks. + +* ``dfhack.internal.setPreferredNumberFormat(value)`` +* ``dfhack.internal.getPreferredNumberFormat()`` + + Sets (gets) the preferred numeric format. ``0`` means no formatting (e.g., + ``1234567``), ``1`` means English formatting (e.g., ``1,234,567``), ``2`` + means system locale formatting (e.g., ``12.345`` on German systems, + ``12,34,567`` on Indian systems, etc.), ``3`` means SI suffix formatting + (e.g., ``12.3M``), and ``4`` means scientific notation (e.g., ``1.23457e+06``). + +For the internal preference values, be aware that setting the values via these +functions will not persist the choice across program invocations. You must set +preferences via the `control-panel` or `gui/control-panel` interfaces for that. + +.. _lua-core-context: + +Core interpreter context +======================== + +While plugins can create any number of interpreter instances, +there is one special context managed by the DFHack core. It is the +only context that can receive events from DF and plugins. + +Core context specific functions: + +* ``dfhack.is_core_context`` + + Boolean value; *true* in the core context. + +* ``dfhack.timeout(time,mode,callback)`` + + Arranges for the callback to be called once the specified + period of time passes. The ``mode`` argument specifies the + unit of time used, and may be one of ``'frames'`` (raw FPS), + ``'ticks'`` (unpaused FPS), ``'days'``, ``'months'``, + ``'years'`` (in-game time). All timers other than + ``'frames'`` are canceled when the world is unloaded, + and cannot be queued until it is loaded again. + Returns the timer id, or *nil* if unsuccessful due to + world being unloaded. + +* ``dfhack.timeout_active(id[,new_callback])`` + + Returns the active callback with the given id, or *nil* + if inactive or nil id. If called with 2 arguments, replaces + the current callback with the given value, if still active. + Using ``timeout_active(id,nil)`` cancels the timer. + +* ``dfhack.onStateChange.foo = function(code)`` + + Creates a handler for state change events. Receives the same + `SC_ codes ` as ``plugin_onstatechange()`` in C++. + + +Event type +---------- + +An event is a native object transparently wrapping a lua table, +and implementing a __call metamethod. When it is invoked, it loops +through the table with next and calls all contained values. +This is intended as an extensible way to add listeners. + +This type itself is available in any context, but only the +`core context ` has the actual events defined by C++ code. + +Features: + +* ``dfhack.event.new()`` + + Creates a new instance of an event. + +* ``event[key] = function`` + + Sets the function as one of the listeners. Assign *nil* to remove it. + + .. note:: + The ``df.NULL`` key is reserved for the use by + the C++ owner of the event; it is an error to try setting it. + +* ``#event`` + + Returns the number of non-nil listeners. + +* ``pairs(event)`` + + Iterates over all listeners in the table. + +* ``event(args...)`` + + Invokes all listeners contained in the event in an arbitrary + order using ``dfhack.safecall``. + + +=========== +Lua Modules +=========== + +.. contents:: + :local: + +DFHack sets up the lua interpreter so that the built-in ``require`` +function can be used to load shared lua code from :file:`hack/lua/`. +The ``dfhack`` namespace reference itself may be obtained via +``require('dfhack')``, although it is initially created as a +global by C++ bootstrap code. + +The following module management functions are provided: + +* ``mkmodule(name)`` + + Creates an environment table for the module. Intended to be used as:: + + local _ENV = mkmodule('foo') + ... + return _ENV + + If called the second time, returns the same table, + thus providing reload support. + +* ``reload(name)`` + + Reloads a previously ``require``-d module *"name"* from the file. + Intended as a help for module development. + +* ``dfhack.BASE_G`` + + This variable contains the root global environment table, which is + used as a base for all module and script environments. Its contents + should be kept limited to the standard Lua library and API described + in this document. + +.. _lua-globals: + +Global environment +================== + +A number of variables and functions are provided in the base global +environment by the mandatory init file dfhack.lua: + +* Color constants + + These are applicable both for ``dfhack.color()`` and color fields + in DF functions or structures:: + + COLOR_RESET, COLOR_BLACK, COLOR_BLUE, COLOR_GREEN, COLOR_CYAN, + COLOR_RED, COLOR_MAGENTA, COLOR_BROWN, COLOR_GREY, COLOR_DARKGREY, + COLOR_LIGHTBLUE, COLOR_LIGHTGREEN, COLOR_LIGHTCYAN, COLOR_LIGHTRED, + COLOR_LIGHTMAGENTA, COLOR_YELLOW, COLOR_WHITE + + ``COLOR_GREY`` and ``COLOR_DARKGREY`` can also be spelled ``COLOR_GRAY`` and + ``COLOR_DARKGRAY``. + + Note: ``COLOR_RESET`` is not valid in a `Pen `, and using it in a Pen color field + will result in runtime warnings and may result in color flashing or other unexpected results. + +* State change event codes, used by ``dfhack.onStateChange`` + + Available only in the `core context `, as is the event itself: + + SC_WORLD_LOADED, SC_WORLD_UNLOADED, SC_MAP_LOADED, + SC_MAP_UNLOADED, SC_VIEWSCREEN_CHANGED, SC_CORE_INITIALIZED + +* Command result constants (equivalent to ``command_result`` in C++), used by + ``dfhack.run_command()`` and related functions: + + CR_OK, CR_LINK_FAILURE, CR_NEEDS_CONSOLE, CR_NOT_IMPLEMENTED, CR_FAILURE, + CR_WRONG_USAGE, CR_NOT_FOUND + +* Functions already described above + + safecall, qerror, mkmodule, reload + +* Miscellaneous constants + + ``NEWLINE``, ``COMMA``, ``PERIOD`` + evaluate to the relevant character strings. + ``DEFAULT_NIL`` + is an unspecified unique token used by the class module below. + +* ``printall(obj)`` + + If the argument is a lua table or DF object reference, prints all fields. + +* ``printall_recurse(obj)`` + + If the argument is a lua table or DF object reference, prints all fields recursively. + +* ``copyall(obj)`` + + Returns a shallow copy of the table or reference as a lua table. + +* ``pos2xyz(obj)`` + + The object must have fields x, y and z. Returns them as 3 values. + If obj is *nil*, or x is -30000 (the usual marker for undefined + coordinates), returns *nil*. + +* ``xyz2pos(x,y,z)`` + + Returns a table with x, y and z as fields. + +* ``same_xyz(a,b)`` + + Checks if ``a`` and ``b`` have the same x, y and z fields. + +* ``get_path_xyz(path,i)`` + + Returns ``path.x[i], path.y[i], path.z[i]``. + +* ``pos2xy(obj)``, ``xy2pos(x,y)``, ``same_xy(a,b)``, ``get_path_xy(a,b)`` + + Same as above, but for 2D coordinates. + +* ``safe_index(obj,index...)`` + + Walks a sequence of dereferences, which may be represented by numbers or strings. + Returns *nil* if any of obj or indices is *nil*, obj isn't indexable, or a numeric + index is out of array bounds. + +* ``ensure_key(t, key[, default_value])`` + + If the Lua table ``t`` doesn't include the specified ``key``, ``t[key]`` is + set to the value of ``default_value``, which defaults to ``{}`` if not set. + The new or existing value of ``t[key]`` is then returned. + +* ``ensure_keys(t, key...)`` + + Walks a series of keys, creating any missing keys as empty tables. The new or + existing table from the last specified key is returned from the function. + +.. _lua-string: + +String class extensions +----------------------- + +DFHack extends Lua's basic string class to include a number of convenience +functions. These are invoked just like standard string functions, e.g.:: + + if imastring:startswith('imaprefix') then + +* ``string:startswith(prefix)`` + + Returns ``true`` if the first ``#prefix`` characters of the string are equal + to ``prefix``. Note that ``prefix`` is not interpreted as a pattern. + +* ``string:endswith(suffix)`` + + Returns ``true`` if the last ``#suffix`` characters of the string are equal + to ``suffix``. Note that ``suffix`` is not interpreted as a pattern. + +* ``string:split([delimiter[, plain]])`` + + Split a string by the given delimiter. If no delimiter is specified, space + (``' '``) is used. The delimiter is treated as a pattern unless a ``plain`` is + specified and set to ``true``. To treat multiple successive delimiter + characters as a single delimiter, e.g., to avoid getting empty string elements, + pass a pattern like ``' +'``. Be aware that passing patterns that match empty + strings (like ``' *'``) will result in improper string splits. + +* ``string:trim()`` + + Removes spaces (i.e., everything that matches ``'%s'``) from the start and end + of a string. Spaces between non-space characters are left untouched. + +* ``string:wrap([width[, opts]])`` + + Inserts newlines into a string so no individual line exceeds the given width. + Lines are split at space-separated word boundaries. Any existing newlines are + kept in place. If a single word is longer than width, it is split over + multiple lines. If ``width`` is not specified, 72 is used. The ``opts`` + parameter can be a table with the following boolean fields specified: + + :return_as_table: if ``true``, then the function will return a table of + strings, with each string representing one wrapped line. Otherwise, a + single multi-line string is returned. + :keep_trailing_spaces: if ``true``, then spaces at the end of a wrapped + line will be kept. Normally, spaces at the end of a wrapped line are + elided. + :keep_original_newlines: if ``true`` (and ``return_as_table`` is also + ``true``), then if a newline was encountered in the original string, it + will be included in the relevant table entry. + +* ``string:escape_pattern()`` + + Escapes regex special chars in a string. E.g., ``'a+b'`` -> ``'a%+b'``. + +.. _script-manager: + +script-manager +============== + +This module contains functions useful for mods that contain DFHack scripts to +retrieve source and state paths. The value to pass as ``mod_id`` must be the +same as the mod ID in the mod's :file:`info.txt` metadata file. The returned +paths will be relative to the top level game directory and will end in a slash +(``/``). + +* ``scriptmanager.getModSourcePath(mod_id)`` + + Retrieve the source directory path for the mod with the given ID or ``nil`` + if the mod cannot be found. If multiple versions of a mod are found, the path + for the version loaded by the current world is used. If the current world + does not have the mod loaded (or if a world is not currently loaded) then the + path for the most recent version of the mod is returned. Example:: + + local scriptmanager = require('script-manager') + local path = scriptmanager.getModSourcePath('my_awesome_mod') + print(path) + + Which would print something like: ``mods/2945575779/`` or + ``data/installed_mods/my_awesome_mod (108)/``, depending on where the mod is + being loaded from. + +* ``scriptmanager.getModStatePath(mod_id)`` + + Retrieve the directory path where a mod with the given ID should store its + persistent state. Example:: + + local json = require('json') + local scriptmanager = require('script-manager') + local path = scriptmanager.getModStatePath('my_awesome_mod') + config = config or json.open(path .. 'settings.json') + + Which would open ``dfhack-config/mods/my_awesome_mod/settings.json``. After + calling ``getModStatePath``, the returned directory is guaranteed to exist. + +* ``get_active_mods()`` + + Returns a list of all active mods in the current world. The list elements are + tables containing the following fields: + + - id: mod id + - name: mod display name + - version: mod display version + - numeric_version: numeric mod version + - path: path to the mod directory + - vanilla: true if this is a vanilla mod + +* ``get_mod_info_metadata(mod_path, tags)`` + + Returns a table with the values of the given tags from the ``info.txt`` file + in the given mod directory. The ``mod_path`` argument must be a path to a mod + directory (retrieved, say, from ``get_active_mods()``). The ``tags`` argument + is a string or a list of strings representing the tags to retrieve. The + function will return a table with the tag names as keys and their values as + values. If a requested tag includes the string ``NUMERIC_``, it will return + the numeric value for that tag (e.g., ``NUMERIC_VERSION`` will return the + numeric version of the mod as a number instead of a string). + +utils +===== + +* ``utils.compare(a,b)`` + + Comparator function; returns *-1* if ab, *0* otherwise. + +* ``utils.compare_name(a,b)`` + + Comparator for names; compares empty string last. + +* ``utils.is_container(obj)`` + + Checks if obj is a container ref. + +* ``utils.make_index_sequence(start,end)`` + + Returns a lua sequence of numbers in start..end. + +* ``utils.invert(table)`` + + Returns a table where keys and values are reversed (i.e., a table containing a + ``value = key`` entry for every ``key = value`` entry in the argument). + +* ``utils.tabulate(fun, start, stop[, step])`` + + For numbers ``start``, ``stop`` and ``step``, with ``step`` defaulting to 1, + returns a lua sequence ``{ fun(start), fun(start+step), ... , fun(stop) }``. + +* ``utils.make_sort_order(data, ordering)`` + + Computes a sorted permutation of objects in data, as a table of integer + indices into the data sequence. Uses ``data.n`` as input length + if present. + + The ordering argument is a sequence of ordering specs, represented + as lua tables with following possible fields: + + ord.key = *function(value)* + Computes comparison key from input data value. Not called on nil. + If omitted, the comparison key is the value itself. + ord.key_table = *function(data)* + Computes a key table from the data table in one go. + ord.compare = *function(a,b)* + Comparison function. Defaults to ``utils.compare`` above. + Called on non-nil keys; nil sorts last. + ord.nil_first = *true/false* + If true, nil keys are sorted first instead of last. + ord.reverse = *true/false* + If true, sort non-nil keys in descending order. + + For every comparison during sorting the specs are applied in + order until an unambiguous decision is reached. Sorting is stable. + + Example of sorting a sequence by field foo:: + + local spec = { key = function(v) return v.foo end } + local order = utils.make_sort_order(data, { spec }) + local output = {} + for i = 1,#order do output[i] = data[order[i]] end + + Separating the actual reordering of the sequence in this + way enables applying the same permutation to multiple arrays. + This function is used by the sort plugin. + +* ``for link,item in utils.listpairs(list)`` + + Iterates a df-list structure, for example ``df.global.world.job_list``. + +* ``utils.assign(tgt, src)`` + + Does a recursive assignment of src into tgt. + Uses ``df.assign`` if tgt is a native object ref; otherwise + recurses into lua tables. + +* ``utils.clone(obj, deep)`` + + Performs a shallow, or semi-deep copy of the object as a lua table tree. + The deep mode recurses into lua tables and subobjects, except pointers + to other heap objects. + Null pointers are represented as ``df.NULL``. Zero-based native containers + are converted to 1-based lua sequences. + +* ``utils.clone_with_default(obj, default, force)`` + + Copies the object, using the ``default`` lua table tree + as a guide to which values should be skipped as uninteresting. + The ``force`` argument makes it always return a non-*nil* value. + +* ``utils.parse_bitfield_int(value, type_ref)`` + + Given an int ``value``, and a bitfield type in the ``df`` tree, + it returns a lua table mapping the enabled bit keys to *true*, + unless value is 0, in which case it returns *nil*. + +* ``utils.list_bitfield_flags(bitfield[, list])`` + + Adds all enabled bitfield keys to ``list`` or a newly-allocated + empty sequence, and returns it. The ``bitfield`` argument may + be *nil*. + +* ``utils.sort_vector(vector,field,cmpfun)`` + + Sorts a native vector or lua sequence using the comparator function. + If ``field`` is not *nil*, applies the comparator to the field instead + of the whole object. + +* ``utils.linear_index(vector,key[,field])`` + + Searches for ``key`` in the vector, and returns *index, found_value*, + or *nil* if none found. + +* ``utils.binsearch(vector,key,field,cmpfun,min,max)`` + + Does a binary search in a native vector or lua sequence for + ``key``, using ``cmpfun`` and ``field`` like sort_vector. + If ``min`` and ``max`` are specified, they are used as the + search subrange bounds. + + If found, returns *item, true, idx*. Otherwise returns + *nil, false, insert_idx*, where *insert_idx* is the correct + insertion point. + +* ``utils.insert_sorted(vector,item,field,cmpfun)`` + + Does a binary search, and inserts item if not found. + Returns *did_insert, vector[idx], idx*. + +* ``utils.insert_or_update(vector,item,field,cmpfun)`` + + Like ``insert_sorted``, but also assigns the item into + the vector cell if insertion didn't happen. + + As an example, you can use this to set skill values:: + + utils.insert_or_update(soul.skills, {new=true, id=..., rating=...}, 'id') + + (For an explanation of ``new=true``, see `lua-api-table-assignment`) + +* ``utils.erase_sorted_key(vector,key,field,cmpfun)`` + + Removes the item with the given key from the list. + Returns: *did_erase, vector[idx], idx*. + +* ``utils.erase_sorted(vector,item,field,cmpfun)`` + + Exactly like ``erase_sorted_key``, but if field is specified, + takes the key from ``item[field]``. + +* ``utils.search_text(text,search_tokens)`` + + Returns true if all the search tokens are found within ``text``. The text and + search tokens are normalized to lower case and special characters (e.g., ``A`` + with a circle on it) are converted to their "basic" forms (e.g., ``a``). + ``search_tokens`` can be a string or a table of strings. If it is a string, + it is split into space-separated tokens before matching. The search tokens + are treated literally, so any special regular expression characters do not + need to be escaped. If ``utils.FILTER_FULL_TEXT`` is ``true``, then the + search tokens can match any part of ``text``. If it is ``false``, then the + matches must happen at the beginning of words within ``text``. You can change + the value of ``utils.FILTER_FULL_TEXT`` in `gui/control-panel` on the + "Preferences" tab. + +* ``utils.call_with_string(obj,methodname,...)`` + + Allocates a temporary string object, calls ``obj:method(tmp,...)``, and + returns the value written into the temporary after deleting it. + +* ``utils.getBuildingName(building)`` + + Returns the string description of the given building. + +* ``utils.getBuildingCenter(building)`` + + Returns an x/y/z table pointing at the building center. + +* ``utils.split_string(string, delimiter)`` + + Splits the string by the given delimiter, and returns a sequence of results. + +* ``utils.prompt_yes_no(prompt, default)`` + + Presents a yes/no prompt to the user. If ``default`` is not *nil*, + allows just pressing Enter to submit the default choice. + If the user enters ``'abort'``, throws an error. + +* ``utils.prompt_input(prompt, checkfun, quit_str)`` + + Presents a prompt to input data, until a valid string is entered. + Once ``checkfun(input)`` returns *true, ...*, passes the values + through. If the user enters the quit_str (defaults to ``'~~~'``), + throws an error. + +* ``utils.check_number(text)`` + + A ``prompt_input`` ``checkfun`` that verifies a number input. + +argparse +======== + +The ``argparse`` module provides functions to help scripts process commandline +parameters. + +* ``argparse.processArgs(args, validArgs)`` + + A basic commandline processing function with simple syntax, useful if your + script doesn't need the more advanced features of + ``argparse.processArgsGetopt()``. + + If ``validArgs`` is specified, it should contain a set of valid option names + (without the leading dashes). For example:: + + argparse.processArgs(args, utils.invert{'opt1', 'opt2', 'opt3'}) + + ``processArgs`` returns a map of option names it found in ``args`` to: + + - the token that came after the option + - ``''`` if the next token was another option + - a list of strings if the next token was ``'['`` (see below) + + Options in ``args`` from the commandline can be prefixed with either one dash + (``'-'``) or two dashes (``'--'``). The user can add a backslash before the + dash to allow a string to be identified as an option value instead of another + option. For example: ``yourscript --opt1 \-arg1``. + + If a ``'['`` token is found in ``args``, the subsequent tokens will be + interpreted as elements of a list until the matching closing ``']'`` is found. + Brackets can be nested, but the inner brackets will be added to the list of + tokens as literal ``'['`` and ``']'`` strings. + + Example commandlines:: + + yourscript --optName --opt2 + yourscript --optName value + yourscript --optName [ list of values ] + yourscript --optName [ list of [ nested values ] [ in square brackets ] ] + yourscript --optName \--value + + Note that ``processArgs`` does not support non-option ("positional") + parameters. They are supported by ``processArgsGetopt`` (see below). + +* ``argparse.processArgsGetopt(args, optionActions)`` + + A fully-featured commandline processing function, with behavior based on the + popular ``getopt`` library. You would use this instead of the simpler + ``processArgs`` function if any of the following are true: + + * You want both short (e.g., ``-f``) and aliased long-form (e.g., + ``--filename``) options + * You have commandline components that are not arguments to options (e.g., you + want to run your script like ``yourscript command --verbose arg1 arg2 arg3`` + instead of + ``yourscript command --verbose --opt1 arg1 --opt2 arg2 --opt3 arg3)``. + * You want the convenience of combining options into shorter strings (e.g., + ``'-abcarg'`` instead of ``'-a -b -c arg``) + * You want to be able to parse and validate the option arguments as the + commandline is being processed, as opposed to validating everything after + commandline processing is complete. + + Commandlines processed by ``processArgsGetopt`` can have both "short" and + "long" options, with each short option often having a long-form alias that + behaves exactly the same as the short form. Short options have properties that + make them very easy to type quickly by users who are familiar with your script + options. Long options, on the other hand, are easily understandable by + everyone and are useful in places where clarity is more important than + brevity, e.g., in example commands. Each option can be configured to take an + argument, which will be the string token that follows the option name on the + commandline. + + Short options are a single letter long and are specified on a commandline by + prefixing them with a single dash (e.g., the short option ``a`` would appear + on the commandline as ``-a``). Multiple successive short options that do not + take arguments can be combined into a single option string (e.g., ``'-abc'`` + instead of ``'-a -b -c'``). Moreover, the argument for a short option can be + appended directly to the single-letter option without an intervening space + (e.g., ``-d param`` can be written as ``-dparam``). These two convenience + shorthand forms can be combined, allowing groups of short parameters to be + written together, as long as at most the last short option takes an argument + (e.g., combining the previous two examples into ``-abcdparam``) + + Long options focus on clarity. They are usually entire words, or several words + combined with hyphens (``-``) or underscores (``_``). If they take an + argument, the argument can be separated from the option name by a space or an + equals sign (``=``). For example, the following two commandlines are + equivalent: ``yourscript --style pretty`` and ``yourscript --style=pretty``. + + Another reason to use long options is if they represent an esoteric parameter + that you don't expect to be commonly used and that you don't want to "waste" a + single-letter option on. In this case, you can define a long option without a + corresponding short option. + + ``processArgsGetopt`` takes two parameters:: + + args: list of space-separated strings the user wrote on the commandline + optionActions: list of option specifications + + and returns a list of positional parameters -- that is, all strings that are + neither options nor arguments to options. Options and positional parameters + can appear in any order on the commandline, as long as arguments to options + immediately follow the option itself. + + Each option specification in ``optionActions`` has the following format: + ``{shortOptionName, longOptionAlias, hasArg=boolean, handler=fn}`` + + * ``shortOptionName`` is a one-character string (or ``''`` or ``nil`` if the + parameter only has a long form). Numbers cannot be short options, and + negative numbers (e.g., ``'-10'``) will be interpreted as positional + parameters and returned in the positional parameters list. + * ``longOptionAlias`` is an optional longer form of the short option name. If + no short option name is specified, then this element is required. + * ``hasArg`` indicates whether the handler function for the option takes a + parameter. + * ``handler`` is the handler function for the option. If ``hasArg`` is + ``true`` then the next token on the commandline is passed to the handler + function as an argument. + + Example usage:: + + local args = {...} + local open_readonly, filename = false, nil -- set defaults + + local positionals = argparse.processArgsGetopt(args, { + {'r', handler=function() open_readonly = true end}, + {'f', 'filename', hasArg=true, + handler=function(optarg) filename = optarg end} + }) + + In this example, if ``args`` is ``{'first', '-rf', 'fname', 'second'}`` or, + equivalently, ``{'first', '-r', '--filename', 'myfile.txt', 'second'}`` (note + the double dash in front of the long option alias), then ``open_readonly`` + will be ``true``, ``filename`` will be ``'myfile.txt'`` and ``positionals`` + will be ``{'first', 'second'}``. + +* ``argparse.stringList(arg, arg_name, list_length)`` + + Parses a comma-separated sequence of strings and returns a lua list. Leading + and trailing spaces are trimmed from the strings. If ``arg_name`` is + specified, it is used to make error messages more useful. If ``list_length`` + is specified and greater than ``0``, then exactly that number of elements must + be found or the function will error. Example:: + + stringList('hello , world,alist', 'words') => {'hello', 'world', 'alist'} + +* ``argparse.numberList(arg, arg_name, list_length)`` + + Parses a comma-separated sequence of numeric strings and returns a list of + the discovered numbers (as numbers, not strings). If ``arg_name`` is + specified, it is used to make error messages more useful. If ``list_length`` + is specified and greater than ``0``, exactly that number of elements must be + found or the function will error. Example:: + + numberList('10, -20 , 30.5') => {10, -20, 30.5} + +* ``argparse.coords(arg, arg_name, skip_validation)`` + + Parses a comma-separated coordinate string and returns a coordinate table of + ``{x, y, z}``. If the string ``'here'`` is passed, returns the coordinates of + the active game cursor, or throws an error if the cursor is not active. This + function also verifies that the coordinates are valid for the current map and + throws if they are not (unless ``skip_validation`` is set to true). + +* ``argparse.positiveInt(arg, arg_name)`` + + Throws if ``tonumber(arg)`` is not a positive integer; otherwise returns + ``tonumber(arg)``. If ``arg_name`` is specified, it is used to make error + messages more useful. + +* ``argparse.nonnegativeInt(arg, arg_name)`` + + Throws if ``tonumber(arg)`` is not a non-negative integer; otherwise returns + ``tonumber(arg)``. If ``arg_name`` is specified, it is used to make error + messages more useful. + +* ``argparse.boolean(arg, arg_name)`` + + Converts ``string.lower(arg)`` from "yes/no/on/off/true/false/etc..." to a lua + boolean. Throws if the value can't be converted, otherwise returns + ``true``/``false``. If ``arg_name`` is specified, it is used to make error + messages more useful. + +dumper +====== + +A third-party lua table dumper module from +http://lua-users.org/wiki/DataDumper. Defines one +function: + +* ``dumper.DataDumper(value, varname, fastmode, ident, indent_step)`` + + Returns ``value`` converted to a string. The ``indent_step`` + argument specifies the indentation step size in spaces. For + the other arguments see the original documentation link above. + +.. _helpdb: + +helpdb +====== + +Unified interface for DFHack tool help text. Help text is read from the rendered +text in ``hack/docs/docs/tools``. If no rendered text exists, help is read from +the script sources (for scripts) or the string passed to the ``PluginCommand`` +initializer (for plugins). See `documentation` for details on how DFHack's help +system works. + +The database is loaded when DFHack initializes, but can be explicitly refreshed +with a call to ``helpdb.refresh()`` if docs are added/changed during a play +session. + +Each entry has several properties associated with it: + +- The entry name, which is the name of a plugin, script, or command provided by + a plugin. +- The entry types, which can be ``builtin``, ``plugin``, and/or ``command``. + Entries for built-in commands (like ``ls`` or ``quicksave``) are both type + ``builtin`` and ``command``. Entries named after plugins are type ``plugin``, + and if that plugin also provides a command with the same name as the plugin, + then the entry is also type ``command``. Entry types are returned as a map + of one or more of the type strings to ``true``. +- Short help, a the ~54 character description string. +- Long help, the entire contents of the associated help file. +- A list of tags that define the groups that the entry belongs to. + +* ``helpdb.refresh()`` + + Scan for changes in available commands and their documentation. + +* ``helpdb.is_entry(str)``, ``helpdb.is_entry(list)`` + + Returns whether the given string (or list of strings) is an entry (are all + entries) in the db. + +* ``helpdb.get_entry_types(entry)`` + + Returns the set (that is, a map of string to ``true``) of entry types for the + given entry. + +* ``helpdb.get_entry_short_help(entry)`` + + Returns the short (~54 character) description for the given entry. + +* ``helpdb.get_entry_long_help(entry[, width])`` + + Returns the full help text for the given entry. If ``width`` is specified, the + text will be wrapped at that width, preserving block indents. The wrap width + defaults to 80. + +* ``helpdb.get_entry_tags(entry)`` + + Returns the set of tag names for the given entry. + +* ``helpdb.has_tag(entry, tag)`` + + Returns whether the given entry exists and has the specified tag. + +* ``helpdb.is_tag(str)``, ``helpdb.is_tag(list)`` + + Returns whether the given string (or list of strings) is a (are all) valid tag + name(s). + +* ``helpdb.get_tags()`` + + Returns the full alphabetized list of valid tag names. + +* ``helpdb.get_tag_data(tag)`` + + Returns a list of entries that have the given tag. The returned table also + has a ``description`` key that contains the string description of the tag. + +* ``helpdb.search_entries([include[, exclude]])`` + + Returns a list of names for entries that match the given filters. The list is + alphabetized by their last path component, with populated path components + coming before null path components (e.g., ``autobutcher`` will immediately + follow ``gui/autobutcher``). + The optional ``include`` and ``exclude`` filter params are maps (or lists of + maps) with the following elements: + + :str: if a string, filters by the given substring. if a table of strings, + includes entry names that match any of the given substrings. + :tag: if a string, filters by the given tag name. if a table of strings, + includes entries that match any of the given tags. + :entry_type: if a string, matches entries of the given type. if a table of + strings, includes entries that match any of the given types. + + Elements in a map are ANDed together (e.g., if both ``str`` and ``tag`` are + specified, the match is on any of the ``str`` elements AND any of the ``tag`` + elements). + + If lists of filters are passed instead of a single map, the match succeeds if + all of the filters match. + + If ``include`` is ``nil`` or empty, then all entries are included. If + ``exclude`` is ``nil`` or empty, then no entries are filtered out. + +profiler +======== + +A third-party lua profiler module from +http://lua-users.org/wiki/PepperfishProfiler. Module defines one function to +create profiler objects which can be used to profile and generate report. + +* ``profiler.newProfiler([variant[, sampling_frequency]])`` + + Returns a profile object with ``variant`` either ``'time'`` or ``'call'``. + ``'time'`` variant takes optional ``sampling_frequency`` parameter to select + lua instruction counts between samples. Default is ``'time'`` variant with + ``10*1000`` frequency. + + ``'call'`` variant has much higher runtime cost which will increase the + runtime of profiled code by factor of ten. For the extreme costs it provides + accurate function call counts that can help locate code which takes much time + in native calls. + +* ``obj:start()`` + + Resets collected statistics. Then it starts collecting new statistics. + +* ``obj:stop()`` + + Stops profile collection. + +* ``obj:report(outfile[, sort_by_total_time])`` + + Write a report from previous statistics collection to ``outfile``. + ``outfile`` should be writeable io file object (``io.open`` or + ``io.stdout``). Passing ``true`` as second parameter ``sort_by_total_time`` + switches sorting order to use total time instead of default self time order. + +* ``obj:prevent(function)`` + + Adds an ignore filter for a ``function``. It will ignore the pointed function + and all of it children. + +Examples +-------- + +:: + + local prof = profiler.newProfiler() + prof:start() + + profiledCode() + + prof:stop() + + local out = io.open( "lua-profile.txt", "w+") + prof:report(out) + out:close() + +class +===== + +Implements a trivial single-inheritance class system. + +* ``Foo = defclass(Foo[, ParentClass])`` + + Defines or updates class Foo. The ``Foo = defclass(Foo)`` syntax + is needed so that when the module or script is reloaded, the + class identity will be preserved through the preservation of + global variable values. + + The ``defclass`` function is defined as a stub in the global + namespace, and using it will auto-load the class module. + +* ``Class.super`` + + This class field is set by defclass to the parent class, and + allows a readable ``Class.super.method(self, ...)`` syntax for + calling superclass methods. + +* ``Class.ATTRS { foo = xxx, bar = yyy }`` + + Declares certain instance fields to be attributes, i.e., auto-initialized + from fields in the table used as the constructor argument. If omitted, + they are initialized with the default values specified in this declaration. + + If the default value should be *nil*, use ``ATTRS { foo = DEFAULT_NIL }``. + + Declaring an attribute is mostly the same as defining your ``init`` method + like this:: + + function Class.init(args) + self.attr1 = args.attr1 or default1 + self.attr2 = args.attr2 or default2 + ... + end + + The main difference is that attributes are processed as a separate + initialization step, before any ``init`` methods are called. They + also make the direct relation between instance fields and constructor + arguments more explicit. + +* ``new_obj = Class{ foo = arg, bar = arg, ... }`` + + Calling the class as a function creates and initializes a new instance. + Initialization happens in this order: + + 1. An empty instance table is created, and its metatable set. + 2. The ``preinit`` methods are called via ``invoke_before`` (see below) + with the table used as the argument to the class. These methods are + intended for validating and tweaking that argument table. + 3. Declared ATTRS are initialized from the argument table or their default values. + 4. The ``init`` methods are called via ``invoke_after`` with the argument table. + This is the main constructor method. + 5. The ``postinit`` methods are called via ``invoke_after`` with the argument table. + Place code that should be called after the object is fully constructed here. + +Predefined instance methods: + +* ``instance:assign{ foo = xxx }`` + + Assigns all values in the input table to the matching instance fields. + +* ``instance:callback(method_name, [args...])`` + + Returns a closure that invokes the specified method of the class, + properly passing in self, and optionally a number of initial arguments too. + The arguments given to the closure are appended to these. + +* ``instance:cb_getfield(field_name)`` + + Returns a closure that returns the specified field of the object when called. + +* ``instance:cb_setfield(field_name)`` + + Returns a closure that sets the specified field to its argument when called. + +* ``instance:invoke_before(method_name, args...)`` + + Navigates the inheritance chain of the instance starting from the most specific + class, and invokes the specified method with the arguments if it is defined in + that specific class. Equivalent to the following definition in every class:: + + function Class:invoke_before(method, ...) + if rawget(Class, method) then + rawget(Class, method)(self, ...) + end + Class.super.invoke_before(method, ...) + end + +* ``instance:invoke_after(method_name, args...)`` + + Like invoke_before, only the method is called after the recursive call to super, + i.e., invocations happen in the parent to child order. + + These two methods are inspired by the Common Lisp before and after methods, and + are intended for implementing similar protocols for certain things. The class + library itself uses them for constructors. + +To avoid confusion, these methods cannot be redefined. + +.. _custom-raw-tokens: + +custom-raw-tokens +================= + +A module for reading custom tokens added to the raws by mods. + +* ``customRawTokens.getToken(typeDefinition, token)`` + + Where ``typeDefinition`` is a type definition struct as seen in + ``df.global.world.raws`` (e.g.: ``dfhack.gui.getSelectedItem().subtype``) + and ``token`` is the name of the custom token you want read. The arguments + from the token will then be returned as strings using single or multiple + return values. If the token is not present, the result is false; if it is present + but has no arguments, the result is true. For ``creature_raw``, it checks against + no caste. For ``plant_raw``, it checks against no growth. + +* ``customRawTokens.getToken(typeInstance, token)`` + + Where ``typeInstance`` is a unit, entity, item, job, projectile, building, + plant, or interaction instance. Gets ``typeDefinition`` and then returns the same + as ``getToken(typeDefinition, token)``. For units, it gets the token from the race + or caste instead if applicable. For plant growth items, it gets the token from the + plant or plant growth instead if applicable. For plants it does the same but with + growth number -1. + +* ``customRawTokens.getToken(raceDefinition, casteNumber, token)`` + + The same as ``getToken(unit, token)`` but with a specified race and caste. + Caste number -1 is no caste. + +* ``customRawTokens.getToken(raceDefinition, casteName, token)`` + + The same as ``getToken(unit, token)`` but with a specified race and caste, using + caste name (e.g., "FEMALE") instead of number. + +* ``customRawTokens.getToken(plantDefinition, growthNumber, token)`` + + The same as ``getToken(plantGrowthItem, token)`` but with a specified plant and + growth. Growth number -1 is no growth. + +* ``customRawTokens.getToken(plantDefinition, growthName, token)`` + + The same as ``getToken(plantGrowthItem, token)`` but with a specified plant and + growth, using growth name (e.g., "LEAVES") instead of number. + +It is recommended to prefix custom raw tokens with the name of your mod to avoid +duplicate behaviour where two mods make callbacks that work on the same tag. + +Examples: + +* Using an eventful onReactionComplete hook, something for disturbing dwarven science:: + + if customRawTokens.getToken(reaction, "EXAMPLE_MOD_CAUSES_INSANITY") then + -- make unit who performed reaction go insane + +* Using an eventful onProjItemCheckMovement hook, a fast or slow-firing crossbow:: + + -- check projectile distance flown is zero, get firer, etc... + local multiplier = tonumber(customRawTokens.getToken(bow, "EXAMPLE_MOD_FIRE_RATE_MULTIPLIER")) or 1 + if firer.counters.think_counter > 0 then + firer.counters.think_counter = math.max(math.floor(firer.counters.think_counter * multiplier), 1) + end + +* Something for a script that prints help text about different types of units:: + + local unit = dfhack.gui.getSelectedUnit() + if not unit then return end + local helpText = customRawTokens.getToken(unit, "EXAMPLE_MOD_HELP_TEXT") + if helpText then print(helpText) end + +* Healing armour:: + + -- (per unit every tick) + local healAmount = 0 + for _, entry in ipairs(unit.inventory) do + if entry.mode == 2 then -- Worn + healAmount = healAmount + tonumber((customRawTokens.getToken(entry.item, "EXAMPLE_MOD_HEAL_AMOUNT")) or 0) + end + end + unit.body.blood_count = math.min(unit.body.blood_max, unit.body.blood_count + healAmount) + +.. _lua-ui-library: + +================== +In-game UI Library +================== + +.. contents:: + :local: + +A number of lua modules with names starting with ``gui`` are dedicated +to wrapping the natives of the ``dfhack.screen`` module in a way that +is easy to use. This allows relatively easily and naturally creating +dialogs that integrate in the main game UI window. + +These modules make extensive use of the ``class`` module, and define +things ranging from the basic ``Painter``, ``View`` and ``Screen`` +classes, to fully functional predefined dialogs. + +gui +=== + +This module defines the most important classes and functions for +implementing interfaces. This documents those of them that are +considered stable. + + +Misc +---- + +* ``CLEAR_PEN`` + + The black pen used to clear the screen. In graphics mode, it will clear the + foreground and set the background to the standard black tile. + +* ``TRANSPARENT_PEN`` + + A pen that will clear all textures from the UI layer, making the tile transparent. + +* ``KEEP_LOWER_PEN`` + + A pen that will write tiles over existing background tiles instead of clearing + them. + +* ``simulateInput(screen, keys...)`` + + This function wraps an undocumented native function that passes a set of + keycodes to a screen, and is the official way to do that. + + Every argument after the initial screen may be *nil*, a numeric keycode, + a string keycode, a sequence of numeric or string keycodes, or a mapping + of keycodes to *true* or *false*. For instance, it is possible to use the + table passed as argument to ``onInput``. The ``_STRING`` convenience field of + an ``onInput`` keys table will be ignored; the presence (or absence) of a + ``STRING_A???`` keycode will determine the text content of the simulated + input. + + You can send mouse clicks as well by setting the ``_MOUSE_L`` key or other + mouse-related pseudo-keys documented with the ``screen:onInput(keys)`` + function above. Note that if you are simulating a click at a specific spot on + the screen, you must set ``df.global.gps.mouse_x`` and + ``df.global.gps.mouse_y`` if you are clicking on the interface layer or + ``df.global.gps.precise_mouse_x`` and ``df.global.gps.precise_mouse_y`` if + you are clicking on the map. + +* ``mkdims_xy(x1,y1,x2,y2)`` + + Returns a table containing the arguments as fields, and also ``width`` and + ``height`` that contains the rectangle dimensions. + +* ``mkdims_wh(x1,y1,width,height)`` + + Returns the same kind of table as ``mkdims_xy``, only this time it computes + ``x2`` and ``y2``. + +* ``get_interface_rect()`` + + Returns the table rect (as per ``mkdims_xy``) for the interface area of the + screen, respecting the player's setting for ``max_interface_percentage``. + +* ``get_interface_frame()`` + + Returns the frame (as per `Widget class`_) for configuring a ``Widget`` with + a body that represents the interface area. + +* ``is_in_rect(rect,x,y)`` + + Checks if the given point is within a rectangle, represented by a table produced + by one of the ``mkdims`` functions. + +* ``blink_visible(delay)`` + + Returns *true* or *false*, with the value switching to the opposite every ``delay`` + msec. This is intended for rendering blinking interface objects. + +* ``getKeyDisplay(keycode)`` + + Wraps ``dfhack.screen.getKeyDisplay`` in order to allow using strings for + the keycode argument. + + +* ``invert_color(color, bold)`` + + This inverts the brightness of ``color``. If this color is coming from a pen's + foreground color, include ``pen.bold`` in ``bold`` for this to work properly. + + +ViewRect class +-------------- + +This class represents an on-screen rectangle with an associated independent +clip area rectangle. It is the base of the ``Painter`` class, and is used by +``Views`` to track their client area. + +* ``ViewRect{ rect = ..., clip_rect = ..., view_rect = ..., clip_view = ... }`` + + The constructor has the following arguments: + + :rect: The ``mkdims`` rectangle in screen coordinates of the logical viewport. + Defaults to the whole screen. + :clip_rect: The clip rectangle in screen coordinates. Defaults to ``rect``. + :view_rect: A ViewRect object to copy from; overrides both ``rect`` and ``clip_rect``. + :clip_view: A ViewRect object to intersect the specified clip area with. + +* ``rect:isDefunct()`` + + Returns *true* if the clip area is empty, i.e., no painting is possible. + +* ``rect:inClipGlobalXY(x,y)`` + + Checks if these global coordinates are within the clip rectangle. + +* ``rect:inClipLocalXY(x,y)`` + + Checks if these coordinates (specified relative to ``x1,y1``) are within the + clip rectangle. + +* ``rect:localXY(x,y)`` + + Converts a pair of global coordinates to local; returns *x_local,y_local*. + +* ``rect:globalXY(x,y)`` + + Converts a pair of local coordinates to global; returns *x_global,y_global*. + +* ``rect:viewport(x,y,w,h)`` or ``rect:viewport(subrect)`` + + Returns a ViewRect representing a sub-rectangle of the current one. + The arguments are specified in local coordinates; the ``subrect`` + argument must be a ``mkdims`` table. The returned object consists of + the exact specified rectangle, and a clip area produced by intersecting + it with the clip area of the original object. + + +Painter class +------------- + +The painting natives in ``dfhack.screen`` apply to the whole screen, are +completely stateless and don't implement clipping. + +The Painter class inherits from ViewRect to provide clipping and local +coordinates, and tracks current cursor position and current pen. It also +supports drawing to a separate map buffer if applicable (see ``map()`` below +for details). + +* ``Painter{ ..., pen = ..., key_pen = ... }`` + + In addition to ViewRect arguments, Painter accepts a suggestion of + the initial value for the main pen, and the keybinding pen. They + default to COLOR_GREY and COLOR_LIGHTGREEN otherwise. + + There are also some convenience functions that wrap this constructor: + + - ``Painter.new(rect,pen)`` + - ``Painter.new_view(view_rect,pen)`` + - ``Painter.new_xy(x1,y1,x2,y2,pen)`` + - ``Painter.new_wh(x1,y1,width,height,pen)`` + +* ``painter:isValidPos()`` + + Checks if the current cursor position is within the clip area. + +* ``painter:viewport(x,y,w,h)`` + + Like the superclass method, but returns a Painter object. + +* ``painter:cursor()`` + + Returns the current cursor *x,y* in screen coordinates. + +* ``painter:cursorX()`` + + Returns just the current *x* cursor coordinate + +* ``painter:cursorY()`` + + Returns just the current *y* cursor coordinate + +* ``painter:seek(x,y)`` + + Sets the current cursor position, and returns *self*. + Either of the arguments may be *nil* to keep the current value. + +* ``painter:advance(dx,dy)`` + + Adds the given offsets to the cursor position, and returns *self*. + Either of the arguments may be *nil* to keep the current value. + +* ``painter:newline([dx])`` + + Advances the cursor to the start of the next line plus the given x offset, + and returns *self*. + +* ``painter:pen(...)`` + + Sets the current pen to ``dfhack.pen.parse(old_pen,...)``, and returns *self*. + +* ``painter:color(fg[,bold[,bg]])`` + + Sets the specified colors of the current pen and returns *self*. + +* ``painter:key_pen(...)`` + + Sets the current keybinding pen to ``dfhack.pen.parse(old_pen,...)``, + and returns *self*. + +* ``painter:map(to_map)`` + + Enables or disables drawing to a separate map buffer. ``to_map`` is a boolean + that will be passed as the ``map`` parameter to any ``dfhack.screen`` functions + that accept it. Note that only third-party plugins like TWBT currently implement + a separate map buffer; if none are enabled, this function has no effect (but + should still be used to ensure proper support for such plugins). Returns *self*. + +* ``painter:clear()`` + + Fills the whole clip rectangle with ``CLEAR_PEN``, and returns *self*. + +* ``painter:fill(x1,y1,x2,y2[,...])`` or ``painter:fill(rect[,...])`` + + Fills the specified local coordinate rectangle with + ``dfhack.pen.parse(cur_pen,...)``, and returns *self*. + +* ``painter:char([char[, ...]])`` + + Paints one character using ``char`` and ``dfhack.pen.parse(cur_pen,...)``. + Returns *self*. The ``char`` argument, if not nil, is used to override the + ``ch`` property of the pen. + +* ``painter:tile([char, tile[, ...]])`` + + Like ``char()`` above, but also allows overriding the ``tile`` property on + ad-hoc basis. + +* ``painter:string(text[, ...])`` + + Paints the string with ``dfhack.pen.parse(cur_pen,...)``; returns *self*. + +* ``painter:key(keycode[, ...])`` + + Paints the description of the keycode using ``dfhack.pen.parse(cur_key_pen,...)``. + Returns *self*. + +* ``painter:key_string(keycode, text, ...)`` + + A convenience wrapper around both ``key()`` and ``string()`` that prints both + the specified keycode description and text, separated by ``:``. Any extra + arguments are passed directly to ``string()``. Returns *self*. + +Unless specified otherwise above, all Painter methods return *self*, in order to +allow chaining them like this:: + + painter:pen(foo):seek(x,y):char(1):advance(1):string('bar')... + + +View class +---------- + +This class is the common abstract base of both the stand-alone screens +and common widgets to be used inside them. It defines the basic layout, +rendering and event handling framework. + +The class defines the following attributes: + +:visible: Specifies that the view should be painted. This can be a boolean or + a function that returns a boolean. +:active: Specifies that the view should receive events, if also visible. This + can be a boolean or a function that returns a boolean. +:view_id: Specifies an identifier to easily identify the view among subviews. + This is reserved for use by script writers and should not be set by + library widgets for their internal subviews. +:on_focus: Called when the view gains keyboard focus; see ``setFocus()`` below. +:on_unfocus: Called when the view loses keyboard focus. + +It also always has the following fields: + +:subviews: Contains a table of all subviews. The sequence part of the + table is used for iteration. In addition, subviews are also + indexed under their ``view_id``, if any; see ``addviews()`` below. +:parent_view: A reference to the parent view. This field is ``nil`` until the + view is added as a subview to another view with ``addviews()``. +:focus_group: The list of widgets in a hierarchy. This table is unique and empty + when a view is initialized, but is replaced by a shared table when + the view is added to a parent via ``addviews()``. If a view in the + focus group has keyboard focus, that widget can be accessed via + ``focus_group.cur``. +:focus: A boolean indicating whether the view currently has keyboard focus. + +These fields are computed by the layout process: + +:frame_parent_rect: The ViewRect representing the client area of the parent view. +:frame_rect: The ``mkdims`` rect of the outer frame in parent-local coordinates. +:frame_body: The ViewRect representing the body part of the View's own frame. + +The class has the following methods: + +* ``view:addviews(list)`` + + Adds the views in the list to the ``subviews`` sequence. If any of the views + in the list have ``view_id`` attributes that don't conflict with existing keys + in ``subviews``, also stores them under the string keys. Finally, copies any + non-conflicting string keys from the ``subviews`` tables of the listed views. + + Thus, doing something like this:: + + self:addviews{ + Panel{ + view_id = 'panel', + subviews = { + Label{ view_id = 'label' } + } + } + } + + Would make the label accessible as both ``self.subviews.label`` and + ``self.subviews.panel.subviews.label``. + +* ``view:getWindowSize()`` + + Returns the dimensions of the ``frame_body`` rectangle. + +* ``view:getMousePos([view_rect])`` + + Returns the mouse *x,y* in coordinates local to the given ViewRect (or + ``frame_body`` if no ViewRect is passed) if it is within its clip area, or + nothing otherwise. + +* ``view:getMouseFramePos()`` + + Returns the mouse *x,y* in coordinates local to ``frame_rect`` if it is + within its clip area, or nothing otherwise. + +* ``view:updateLayout([parent_rect])`` + + Recomputes layout of the view and its subviews. If no argument is + given, re-uses the previous parent rect. The process goes as follows: + + 1. Calls ``preUpdateLayout(parent_rect)`` via ``invoke_before``. + 2. Uses ``computeFrame(parent_rect)`` to compute the desired frame. + 3. Calls ``postComputeFrame(frame_body)`` via ``invoke_after``. + 4. Calls ``updateSubviewLayout(frame_body)`` to update children. + 5. Calls ``postUpdateLayout(frame_body)`` via ``invoke_after``. + +* ``view:computeFrame(parent_rect)`` *(for overriding)* + + Called by ``updateLayout`` in order to compute the frame rectangle(s). + Should return the ``mkdims`` rectangle for the outer frame, and optionally + also for the body frame. If only one rectangle is returned, it is used + for both frames, and the margin becomes zero. + +* ``view:updateSubviewLayout(frame_body)`` + + Calls ``updateLayout`` on all children. + +* ``view:render(painter)`` + + Given the parent's painter, renders the view via the following process: + + 1. Calls ``onRenderFrame(painter, frame_rect)`` to paint the outer frame. + 2. Creates a new painter using the ``frame_body`` rect. + 3. Calls ``onRenderBody(new_painter)`` to paint the client area. + 4. Calls ``renderSubviews(new_painter)`` to paint visible children. + +* ``view:renderSubviews(painter)`` + + Calls ``render`` on all ``visible`` subviews in the order they + appear in the ``subviews`` sequence. + +* ``view:onRenderFrame(painter, rect)`` *(for overriding)* + + Called by ``render`` to paint the outer frame; by default does nothing. + +* ``view:onRenderBody(painter)`` *(for overriding)* + + Called by ``render`` to paint the client area; by default does nothing. + +* ``view:onInput(keys)`` *(for overriding)* + + Override this to handle events. By default directly calls ``inputToSubviews``. + Return a true value from this method to signal that the event has been handled + and should not be passed on to more views. + +* ``view:inputToSubviews(keys)`` + + Calls ``onInput`` on all visible active subviews, iterating the ``subviews`` + sequence in *reverse order*, so that topmost subviews get events first. + Returns ``true`` if any of the subviews handled the event. If a subview within + the view's ``focus_group`` has focus and it and all of its ancestors are + active and visible, that subview is offered the chance to handle the input + before any other subviews. + +* ``view:getPreferredFocusState()`` + + Returns ``false`` by default, but should be overridden by subclasses that may + want to take keyboard focus (if it is unclaimed) when they are added to a + parent view with ``addviews()``. + +* ``view:setFocus(focus)`` + + Sets the keyboard focus to the view if ``focus`` is ``true``, or relinquishes + keyboard focus if ``focus`` is ``false``. Views that newly acquire keyboard + focus will trigger the ``on_focus`` callback, and views that lose keyboard + focus will trigger the ``on_unfocus`` callback. While a view has focus, all + keyboard input is sent to that view before any of its siblings or parents. + Keyboard input is propagated as normal (see ``inputToSubviews()`` above) if + there is no view with focus or if the view with focus returns ``false`` from + its ``onInput()`` function. + +.. _lua-gui-screen: + +Screen class +------------ + +This is a View subclass intended for use as a stand-alone modal dialog or screen. +It adds the following methods: + +* ``screen:isShown()`` + + Returns *true* if the screen is currently in the game engine's display stack. + +* ``screen:isDismissed()`` + + Returns *true* if the screen is dismissed. + +* ``screen:isActive()`` + + Returns *true* if the screen is shown and not dismissed. + +* ``screen:invalidate()`` + + Requests a repaint. Note that currently using it is not necessary, because + repaints are constantly requested automatically, due to issues with native + screens happening otherwise. + +* ``screen:renderParent()`` + + Asks the parent native screen to render itself, or clears the screen + if impossible. + +* ``screen:sendInputToParent(...)`` + + Uses ``simulateInput`` to send keypresses to the native parent screen. + +* ``screen:show([parent])`` + + Adds the screen to the display stack with the given screen as the parent; + if parent is not specified, places this one one topmost. Before calling + ``dfhack.screen.show``, calls ``self:onAboutToShow(parent)``. Note that + ``onAboutToShow()`` can dismiss active screens, and therefore change the + potential parent. If parent is not specified, this function will re-detect + the current topmost window after ``self:onAboutToShow(parent)`` returns. + This function returns ``self`` as a convenience so you can write such code + as ``local view = MyScreen{params=val}:show()``. + +* ``screen:onAboutToShow(parent)`` *(for overriding)* + + Called when ``dfhack.screen.show`` is about to be called. + +* ``screen:onShow()`` + + Called by ``dfhack.screen.show`` once the screen is successfully shown. + +* ``screen:dismiss()`` + + Dismisses the screen. A dismissed screen does not receive any more + events or paint requests, but may remain in the display stack for + a short time until the game removes it. + +* ``screen:onDismiss()`` *(for overriding)* + + Called by ``dfhack.screen.dismiss()``. + +* ``screen:onDestroy()`` *(for overriding)* + + Called by the native code when the screen is fully destroyed and removed + from the display stack. Place code that absolutely must be called whenever + the screen is removed by any means here. + +* ``screen:onResize``, ``screen:onRender`` + + Defined as callbacks for native code. + +ZScreen class +------------- + +A screen subclass that allows multi-layer interactivity. For example, a DFHack +GUI tool implemented as a ZScreen can allow the player to interact with the +underlying map, or even other DFHack ZScreen windows! That is, even when the +DFHack tool window is visible, players will be able to use vanilla designation +tools, select units, and scan/drag the map around. + +At most one ZScreen can have input focus at a time. That ZScreen's widgets +will have a chance to handle the input before anything else. If unhandled, the +input skips all unfocused ZScreens under that ZScreen and is passed directly to +the first non-ZScreen viewscreen. There are class attributes that can be set to +control what kind of unhandled input is passed to the lower layers. + +If multiple ZScreens are visible and the player scrolls or left/right clicks on +a visible element of a non-focused ZScreen, that ZScreen will be given focus. +This allows multiple DFHack GUI tools to be usable at the same time. If the +mouse is clicked away from the ZScreen widgets, that ZScreen loses focus. If no +ZScreen has focus, all input is passed directly through to the first underlying +non-ZScreen viewscreen. + +For a ZScreen with keyboard focus, if :kbd:`Esc` or the right mouse button is +pressed, and the ZScreen widgets don't otherwise handle them, then the ZScreen +is dismissed. + +All this behavior is implemented in ``ZScreen:onInput()``, which subclasses +**must not override**. Instead, ZScreen subclasses should delegate all input +processing to subviews. Consider using a `Window class`_ widget subview as your +top level input processor. + +When rendering, the parent viewscreen is automatically rendered first, so +subclasses do not have to call ``self:renderParent()``. Calls to ``logic()`` +(a world "tick" when playing the game) are also passed through, so the game +progresses normally and can be paused/unpaused as normal by the player. Note +that passing ``logic()`` calls through to the underlying map is required for +allowing the player to drag the map with the mouse. ZScreen subclasses can set +attributes that control whether the game is paused when the ZScreen is shown and +whether the game is forced to continue being paused while the ZScreen is shown. +If pausing is forced, child ``Window`` widgets will show a force-pause indicator +to show which tool is forcing the pausing. + +ZScreen provides the following functions: + +* ``zscreen:raise()`` + + Raises the ZScreen to the top of the viewscreen stack, gives it keyboard + focus, and returns a reference to ``self``. A common pattern is to check if + a tool dialog is already active when the tool command is run and raise the + existing dialog if it exists or show a new dialog if it doesn't. See the + sample code below for an example. + +* ``zscreen:isMouseOver()`` + + The default implementation iterates over the direct subviews of the ZScreen + subclass (which usually only includes a single Window subview) and sees if + ``getMouseFramePos()`` returns a position for any of them. Subclasses can + override this function if that logic is not appropriate. + +* ``zscreen:hasFocus()`` + + Whether the ZScreen has keyboard focus. Subclasses will generally not need to + check this because they can assume if they are getting input, then they have + focus. + +ZScreen subclasses can set the following attributes: + +* ``defocusable`` (default: ``true``) + + Whether the ZScreen loses keyboard focus when the player clicks on an area + of the screen other than the tool window. If the player clicks on a different + ZScreen window, focus still transfers to that other ZScreen. + +* ``defocused`` (default: ``false``) + + Whether the ZScreen starts in a defocused state. + +* ``initial_pause`` (default: ``DEFAULT_INITIAL_PAUSE or not pass_mouse_clicks``) + + Whether to pause the game when the ZScreen is shown. If not explicitly set, + this attribute will be true if the system-wide ``DEFAULT_INITIAL_PAUSE`` is + ``true`` (which is its default value) or if the ``pass_mouse_clicks`` attribute + is ``false`` (see below). It depends on ``pass_mouse_clicks`` because if the + player normally pauses/unpauses the game with the mouse, they will not be able + to pause the game like they usually do while the ZScreen has focus. + ``DEFAULT_INITIAL_PAUSE`` can be customized permanently via `gui/control-panel` + or set for the session by running a command like:: + + :lua require('gui.widgets').DEFAULT_INITIAL_PAUSE = false + +* ``force_pause`` (default: ``false``) + + Whether to ensure the game *stays* paused while the ZScreen is shown, + regardless of whether it has input focus. + +* ``pass_pause`` (default: ``true``) + + Whether to pass the pause key to the lower viewscreens if it is not handled + by this ZScreen. + +* ``pass_movement_keys`` (default: ``false``) + + Whether to pass the map movement keys to the lower viewscreens if they are not + handled by this ZScreen. + +* ``pass_mouse_clicks`` (default: ``true``) + + Whether to pass mouse clicks to the lower viewscreens if they are not handled + by this ZScreen. + +Here is an example skeleton for a ZScreen tool window:: + + local gui = require('gui') + local widgets = require('gui.widgets') + + MyWindow = defclass(MyWindow, widgets.Window) + MyWindow.ATTRS { + frame_title='My Window', + frame={w=50, h=45}, + resizable=true, -- if resizing makes sense for your dialog + resize_min={w=50, h=20}, -- try to allow users to shrink your windows + } + + function MyWindow:init() + self:addviews{ + -- add subview widgets here + } + end + + -- implement if you need to handle custom input + --function MyWindow:onInput(keys) + -- return MyWindow.super.onInput(self, keys) + --end + + MyScreen = defclass(MyScreen, gui.ZScreen) + MyScreen.ATTRS { + focus_path='myscreen', + -- set pause and passthrough attributes as appropriate + -- (but most tools can use the defaults) + } + + function MyScreen:init() + self:addviews{MyWindow{}} + end + + function MyScreen:onDismiss() + view = nil + end + + view = view and view:raise() or MyScreen{}:show() + +ZScreenModal class +------------------ + +A ZScreen convenience subclass that sets the attributes to something +appropriate for modal dialogs. The game is force paused, and no input is passed +through to the underlying viewscreens. + +gui.widgets +=========== + +This module implements some basic widgets based on the View infrastructure. + +.. _widget: + +Widget class +------------ + +Base of all the widgets. Inherits from View and has the following attributes: + +* ``frame = {...}`` + + Specifies the constraints on the outer frame of the widget. + If omitted, the widget will occupy the whole parent rectangle. + + The frame is specified as a table with the following possible fields: + + :l: gap between the left edges of the frame and the parent. + :t: gap between the top edges of the frame and the parent. + :r: gap between the right edges of the frame and the parent. + :b: gap between the bottom edges of the frame and the parent. + :w: maximum width of the frame. + :h: maximum height of the frame. + :xalign: X alignment of the frame. + :yalign: Y alignment of the frame. + + First the ``l,t,r,b`` fields restrict the available area for + placing the frame. If ``w`` and ``h`` are not specified or + larger than the computed area, it becomes the frame. Otherwise + the smaller frame is placed within the are based on the + ``xalign/yalign`` fields. If the align hints are omitted, they + are assumed to be 0, 1, or 0.5 based on which of the ``l/r/t/b`` + fields are set. + +* ``frame_inset = {...}`` + + Specifies the gap between the outer frame, and the client area. + The attribute may be a simple integer value to specify a uniform + inset, or a table with the following fields: + + :l: left margin. + :t: top margin. + :r: right margin. + :b: bottom margin. + :x: left/right margin, if ``l`` and/or ``r`` are omitted. + :y: top/bottom margin, if ``t`` and/or ``b`` are omitted. + + Omitted fields are interpreted as having the value of 0. + +* ``frame_background = pen`` + + The pen to fill the outer frame with. Defaults to no fill. + +.. _panel: + +Panel class +----------- + +Inherits from Widget, and intended for framing and/or grouping subviews. Though +this can be used for your "main window", see the `Window class`_ below for a +more conveniently configured ``Panel`` subclass. + +Has attributes: + +* ``subviews = {}`` + + Used to initialize the subview list in the constructor. + +* ``on_render = function(painter)`` + + Called from ``onRenderBody``. + +* ``on_layout = function(frame_body)`` + + Called from ``postComputeFrame``. + +* ``draggable = bool`` (default: ``false``) +* ``drag_anchors = {}`` (default: ``{title=true, frame=false/true, body=true}``) +* ``drag_bound = 'frame' or 'body'`` (default: ``'frame'``) +* ``on_drag_begin = function()`` (default: ``nil``) +* ``on_drag_end = function(success, new_frame)`` (default: ``nil``) + + If ``draggable`` is set to ``true``, then the above attributes come into play + when the panel is dragged around the screen, either with the mouse or the + keyboard. ``drag_anchors`` sets which parts of the panel can be clicked on + with the left mouse button to start dragging. The frame is a drag anchor by + default only if ``resizable`` (below) is ``false``. ``drag_bound`` configures + whether the frame of the panel (if any) can be dragged outside the containing + parent's boundary. The body will never be draggable outside of the parent, + but you can allow the frame to cross the boundary by setting ``drag_bound`` to + ``'body'``. The boolean passed to the ``on_drag_end`` callback will be + ``true`` if the drag was "successful" (i.e., not canceled) and ``false`` + otherwise. Dragging can be canceled by right clicking while dragging with the + mouse, hitting :kbd:`Esc` (while dragging with the mouse or keyboard), or by + calling ``Panel:setKeyboardDragEnabled(false)`` (while dragging with the + keyboard). If it is more convenient to do so, you can choose to override the + ``panel:onDragBegin`` and/or the ``panel:onDragEnd`` methods instead of + setting the ``on_drag_begin`` and/or ``on_drag_end`` attributes. + +* ``resizable = bool`` (default: ``false``) +* ``resize_anchors = {}`` (default: ``{t=false, l=true, r=true, b=true}`` +* ``resize_min = {}`` (default: w and h from the ``frame``, or ``{w=5, h=5}``) +* ``on_resize_begin = function()`` (default: ``nil``) +* ``on_resize_end = function(success, new_frame)`` (default: ``nil``) + + If ``resizable`` is set to ``true``, then the player can click the mouse on + any edge specified in ``resize_anchors`` and drag the border to resize the + window. If two adjacent edges are enabled as anchors, then the tile where they + meet can be used to resize both edges at the same time. The minimum dimensions + specified in ``resize_min`` (or inherited from ``frame`` are respected when + resizing. The panel is also prevented from resizing beyond the boundaries of + its parent. When the player clicks on a valid anchor, ``on_resize_begin()`` is + called. The boolean passed to the ``on_resize_end`` callback will be ``true`` + if the drag was "successful" (i.e., not canceled) and ``false`` otherwise. + Dragging can be canceled by right clicking while resizing with the mouse, + hitting :kbd:`Esc` (while resizing with the mouse or keyboard), or by calling + ``Panel:setKeyboardResizeEnabled(false)`` (while resizing with the keyboard). + If it is more convenient to do so, you can choose to override the + ``panel:onResizeBegin`` and/or the ``panel:onResizeEnd`` methods instead of + setting the ``on_resize_begin`` and/or ``on_resize_end`` attributes. + +* ``autoarrange_subviews = bool`` (default: ``false``) +* ``autoarrange_gap = int`` (default: ``0``) + + If ``autoarrange_subviews`` is set to ``true``, the Panel will + automatically handle subview layout. Subviews are laid out vertically + according to their current height, with ``autoarrange_gap`` empty lines + between subviews. This allows you to have widgets dynamically change + height or become visible/hidden and you don't have to worry about + recalculating subview positions. + +* ``frame_style``, ``frame_title`` (default: ``nil``) + + If defined, a frame will be drawn around the panel and subviews will be + inset by 1. The following predefined frame styles are defined: + + * ``FRAME_WINDOW`` + + A frame suitable for a draggable, optionally resizable window. + + * ``FRAME_PANEL`` + + A frame suitable for a static (non-resizable) panel. + + * ``FRAME_MEDIUM`` + + A frame suitable for overlay widget panels. + + * ``FRAME_THIN`` + + A frame suitable for floating tooltip panels that need the DFHack signature. + + * ``FRAME_BOLD`` + + A frame suitable for a non-draggable panel meant to capture the user's + focus, like an important notification, confirmation dialog or error message. + + * ``FRAME_INTERIOR`` + + A frame suitable for light interior accent elements. This frame does *not* + have a visible ``DFHack`` signature on it, so it must not be used as the + external frame for a DFHack-owned UI. + + * ``FRAME_INTERIOR_MEDIUM`` + + A copy of ``FRAME_MEDIUM`` that lacks the ``DFHack`` signature. Suitable for + panels that are part of a larger widget cluster. Must *not* be used as the + external frame for a DFHack-owned UI. + + When using the predefined frame styles in the ``gui`` module, remember to + ``require`` the gui module and prefix the identifier with ``gui.``, e.g., + ``gui.FRAME_THIN``. + +* ``no_force_pause_badge`` (default: ``false``) + + If true, then don't display the PAUSE FORCED badge on the frame even if the + game has been force paused. + +Has functions: + +* ``panel:setKeyboardDragEnabled(bool)`` + + If called with ``true`` and the panel is not already in keyboard drag mode, + then any current drag or resize operations are halted where they are (not + canceled), the panel seizes input focus (see `View class`_ above for + information on the DFHack focus subsystem), and further keyboard cursor keys + move the window as if it were being dragged. Shift-cursor keys move by larger + amounts. Hit :kbd:`Enter` to commit the new window position or :kbd:`Esc` to + cancel. If dragging is canceled, then the window is moved back to its original + position. + +* ``panel:setKeyboardResizeEnabled(bool)`` + + If called with ``true`` and the panel is not already in keyboard resize mode, + then any current drag or resize operations are halted where they are (not + canceled), the panel seizes input focus (see `View class`_ above for + information on the DFHack focus subsystem), and further keyboard cursor keys + resize the window as if it were being dragged from the lower right corner. If + neither the bottom or right edge is a valid anchor, an appropriate corner will + be chosen. Shift-cursor keys move by larger amounts. Hit :kbd:`Enter` to + commit the new window size or :kbd:`Esc` to cancel. If resizing is canceled, + then the window size from before the resize operation is restored. + +* ``panel:onDragBegin()`` +* ``panel:onDragEnd(success, new_frame)`` +* ``panel:onResizeBegin()`` +* ``panel:onResizeEnd(success, new_frame)`` + +The default implementations of these methods call the associated attribute (if +set). You can override them in a subclass if that is more convenient than +setting the attributes. + +Double clicking: + +If the panel is resizable and the user double-clicks on the top edge (the frame +title, if the panel has a frame), then the panel will jump to its maximum size. +If the panel has already been maximized in this fashion, then it will jump to +its minimum size. Both jumps respect the resizable edges defined by the +``resize_anchors`` attribute. + +The time duration that a double click can span can be controlled via the +`control-panel` or `gui/control-panel` interfaces (``Mouse double click speed`` +option). It defaults to 500 ms. + +Window class +------------ + +Subclass of Panel; sets Panel attributes to useful defaults for a top-level +framed, draggable window. + +ResizingPanel class +------------------- + +Subclass of Panel; automatically adjusts its own frame height and width to the +minimum required to show its subviews. Pairs nicely with a parent Panel that has +``autoarrange_subviews`` enabled. + +It has the following attributes: + +:auto_height: Sets self.frame.h from the positions and height of its subviews + (default is ``true``). +:auto_width: Sets self.frame.w from the positions and width of its subviews + (default is ``false``). + +Pages class +----------- + +Subclass of Panel; keeps exactly one child visible. + +* ``Pages{ ..., selected = ... }`` + + Specifies which child to select initially; defaults to the first one. + +* ``pages:getSelected()`` + + Returns the selected *index, child*. + +* ``pages:setSelected(index)`` + + Selects the specified child, hiding the previous selected one. + It is permitted to use the subview object, or its ``view_id`` as index. + +Divider class +------------- + +Subclass of Widget; implements a divider line that can optionally connect to +existing frames via T-junction edges. A ``Divider`` instance is required to +have a ``frame`` that is either 1 unit tall or 1 unit wide. + +``Divider`` widgets should be a sibling with the framed ``Panel`` that they +are dividing, and they should be added to the common parent widget **after** +the ``Panel`` so that the ``Divider`` can overwrite the ``Panel`` frame with +the appropriate T-junction graphic. If the ``Divider`` will not have +T-junction edges, then it could potentially be a child of the ``Panel`` since +the ``Divider`` won't need to overwrite the ``Panel``'s frame. + +If two ``Divider`` widgets are set to cross, then you must have a third 1x1 +``Divider`` widget for the crossing tile so the other two ``Divider``\s can +be seamlessly connected. + +Attributes: + +* ``frame_style`` + + The ``gui`` ``FRAME`` instance to use for the graphical tiles. Defaults to + ``gui.FRAME_THIN``. + +* ``interior`` + + Whether the edge T-junction tiles should connect to interior lines (e.g., the + vertical or horizontal segment of another ``Divider`` instance) or the + exterior border of a ``Panel`` frame. Defaults to ``false``, meaning + exterior T-junctions will be chosen. + +* ``frame_style_t`` +* ``frame_style_b`` +* ``frame_style_l`` +* ``frame_style_r`` + + Overrides for the frame style for specific T-junctions. Note that there are + not currently any frame styles that allow borders of different weights to be + seamlessly connected. If set to ``false``, then the indicated edge will end + in a straight segment instead of a T-junction. + +* ``interior_t`` +* ``interior_b`` +* ``interior_l`` +* ``interior_r`` + + Overrides for the interior/exterior specification for specific T-junctions. + +EditField class +--------------- + +Subclass of Widget; implements a simple edit field. + +Attributes: + +:label_text: The optional text label displayed before the editable text. +:text: The current contents of the field. +:text_pen: The pen to draw the text with. +:on_char: Input validation callback; used as ``on_char(new_char,text)``. + If it returns false, the character is ignored. +:on_change: Change notification callback; used as ``on_change(new_text,old_text)``. +:on_submit: Enter key callback; if set the field will handle the key and call ``on_submit(text)``. +:key: If specified, the field is disabled until this key is pressed. Must be given as a string. +:key_sep: If specified, will be used to customize how the activation key is + displayed. See ``token.key_sep`` in the ``Label`` documentation below. +:modal: Whether the ``EditField`` should prevent input from propagating to other + widgets while it has focus. You can set this to ``true``, for example, + if you don't want a ``List`` widget to react to arrow keys while the + user is editing. +:ignore_keys: If specified, must be a list of key names that the edit field + should ignore. This is useful if you have plain string characters + that you want to use as hotkeys (like ``+``). + +An ``EditField`` will only read and process text input if it has keyboard focus. +It will automatically acquire keyboard focus when it is added as a subview to +a parent that has not already granted keyboard focus to another widget. If you +have more than one ``EditField`` on a screen, you can select which has focus by +calling ``setFocus(true)`` on the field object. + +If an activation ``key`` is specified, the ``EditField`` will manage its own +focus. It will start in the unfocused state, and pressing the activation key +will acquire keyboard focus. Pressing the Enter key will release keyboard focus +and then call the ``on_submit`` callback. Pressing the Escape key (or r-clicking +with the mouse) will also release keyboard focus, but first it will restore the +text that was displayed before the ``EditField`` gained focus and then call the +``on_change`` callback. + +The ``EditField`` cursor can be moved to where you want to insert/remove text. +You can click where you want the cursor to move or you can use any of the +following keyboard hotkeys: + +- Left/Right arrow: move the cursor one character to the left or right +- Ctrl-Left/Ctrl-Right: move the cursor one word back or forward +- Home/End: move the cursor to the beginning/end of the text + +The widget also supports integration with the system clipboard: + +- Ctrl-C: copy current text to the system clipboard +- Ctrl-X: copy current text to the system clipboard and clear text in widget +- Ctrl-V: paste text from the system clipboard (text is converted to cp437) + +The ``EditField`` class also provides the following functions: + +* ``editfield:setCursor([cursor_pos])`` + + Sets the text insert cursor to the specified position. If ``cursor_pos`` is + not specified or is past the end of the current text string, the cursor will + be set to the end of the current input (that is, ``#editfield.text + 1``). + +* ``editfield:setText(text[, cursor_pos])`` + + Sets the input text string and, optionally, the cursor position. If the + cursor position is not specified, it sets it to the end of the string. + +* ``editfield:insert(text)`` + + Inserts the given text at the current cursor position. + +TextArea class +-------------- + +Subclass of Panel; implements a multi-line text field with features such as +text wrapping, mouse control, text selection, clipboard support, history, +and typical text editor shortcuts. + +Cursor Behavior +~~~~~~~~~~~~~~~ + +The cursor in the ``TextArea`` class is index-based, starting from 1, +consistent with Lua's text indexing conventions. + +Each character, including newlines (``string.char(10)``), +occupies a single index in the text content. + +Cursor movement and position are fully aware of line breaks, +meaning they count as one unit in the offset. + +The cursor always points to the position between characters, +with 1 being the position before the first character and +``#text + 1`` representing the position after the last character. + +Cursor positions are preserved during text operations like insertion, +deletion, or replacement. If changes affect the cursor's position, +it will be adjusted to the nearest valid index. + +TextArea Attributes: + +* ``init_text``: The initial text content for the text area. + +* ``init_cursor``: The initial cursor position within the text content. + If not specified, defaults to end of the text (length of ``init_text`` + 1). + +* ``text_pen``: Optional pen used to draw the text. Default is ``COLOR_LIGHTCYAN``. + +* ``select_pen``: Optional pen used for text selection. Default is ``COLOR_CYAN``. + +* ``ignore_keys``: List of input keys to ignore. + Functions similarly to the ``ignore_keys`` attribute in the ``EditField`` class. + +* ``on_text_change``: Callback function called whenever the text changes. + The function signature should be ``on_text_change(new_text, old_text)``. + +* ``on_cursor_change``: Callback function called whenever the cursor position changes. + Expected function signature is ``on_cursor_change(new_cursor, old_cursor)``. + +* ``one_line_mode``: If set to ``true``, disables multi-line text features. + In this mode the :kbd:`Enter` key is not handled by the widget + as if it were included in ``ignore_keys``. + If multiline text (including ``\n`` chars) is pasted into the widget, newlines are removed. + +TextArea Functions: + +* ``textarea:getText()`` + + Returns the current text content of the ``TextArea`` widget as a string. + ``\n`` characters (``string.char(10)``) should be interpreted as new lines + +* ``textarea:setText(text)`` + + Sets the content of the ``TextArea`` to the specified string ``text``. + The cursor position will not be adjusted, so should be set separately. + +* ``textarea:getCursor()`` + + Returns the current cursor position within the text content. + The position is represented as a single integer, starting from 1. + +* ``textarea:setCursor(cursor)`` + + Sets the cursor position within the text content. + +* ``textarea:scrollToCursor()`` + + Scrolls the text area view to ensure that the current cursor position is visible. + This happens automatically when the user interactively moves the cursor or + pastes text into the widget, but may need to be called when ``setCursor`` is + called programmatically. + +* ``textarea:clearHistory()`` + + Clears undo/redo history of the widget. + +Functionality +~~~~~~~~~~~~~ + +The TextArea widget provides a familiar and intuitive text editing experience with baseline features such as: + +- Text Wrapping: Automatically fits text within the display area. +- Mouse and Keyboard Support: Standard keys like :kbd:`Home`, :kbd:`End`, :kbd:`Backspace`, and :kbd:`Delete` are supported, + along with gestures like double-click to select a word or triple-click to select a line. +- Clipboard Operations: copy, cut, and paste, + with intuitive defaults when no text is selected. +- Undo/Redo: :kbd:`Ctrl` + :kbd:`Z` and :kbd:`Ctrl` + :kbd:`Y` for quick changes. +- Additional features include advanced navigation, line management, + and smooth scrolling for handling long text efficiently. + +Detailed list: + +- Cursor Control: Navigate through text using arrow keys (Left, Right, Up, + and Down) for precise cursor placement. +- Mouse Control: Use the mouse to position the cursor within the text, + providing an alternative to keyboard navigation. +- Text Selection: Select text with the mouse, with support for replacing or + removing selected text. +- Select Word/Line: Use double click to select current word, or triple click to + select current line. +- Move By Word: Use :kbd:`Ctrl` + :kbd:`Left` and :kbd:`Ctrl` + :kbd:`Right` to + move the cursor one word back or forward. +- Line Navigation: :kbd:`Home` moves the cursor to the beginning of the current + line, and :kbd:`End` moves it to the end. +- Jump to Beginning/End: Quickly move the cursor to the beginning or end of the + text using :kbd:`Ctrl` + :kbd:`Home` and :kbd:`Ctrl` + :kbd:`End`. +- Longest X Position Memory: The cursor remembers the longest x position when + moving up or down, making vertical navigation more intuitive. +- New Lines: Easily insert new lines using the :kbd:`Enter` key, supporting + multiline text input. +- Text Wrapping: Text automatically wraps within the editor, ensuring lines fit + within the display without manual adjustments. +- Scrolling for long text entries. +- Backspace Support: Use the backspace key to delete characters to the left of + the cursor. +- Delete Character: :kbd:`Delete` deletes the character under the cursor. +- Delete Current Line: :kbd:`Ctrl` + :kbd:`U` deletes the entire current line + where the cursor is located. +- Delete Rest of Line: :kbd:`Ctrl` + :kbd:`K` deletes text from the cursor to + the end of the line. +- Delete Last Word: :kbd:`Ctrl` + :kbd:`W` removes the word immediately before + the cursor. +- Select All: Select entire text by :kbd:`Ctrl` + :kbd:`A`. +- Undo/Redo: Undo/Redo changes by :kbd:`Ctrl` + :kbd:`Z` / :kbd:`Ctrl` + + :kbd:`Y`. +- Clipboard Operations: Perform OS clipboard cut, copy, and paste operations on + selected text, allowing you to paste the copied content into other + applications. +- Copy Text: Use :kbd:`Ctrl` + :kbd:`C` to copy selected text. + - copy selected text, if available + - if no text is selected it copy the entire current line, including the + terminating newline if present +- Cut Text: Use :kbd:`Ctrl` + :kbd:`X` to cut selected text. + - cut selected text, if available + - if no text is selected it will cut the entire current line, including the + terminating newline if present +- Paste Text: Use :kbd:`Ctrl` + :kbd:`V` to paste text from the clipboard into + the editor. + - replace selected text, if available + - If no text is selected, paste text in the cursor position + +Scrollbar class +--------------- + +This Widget subclass implements mouse-interactive scrollbars whose bar sizes +represent the amount of content currently visible in an associated display +widget (like a `Label class`_ or a `List class`_). They are styled like scrollbars +used in vanilla DF. + +Scrollbars have the following attributes: + +:on_scroll: A callback called when the scrollbar is scrolled. If the scrollbar + is clicked, the callback will be called with one of the following string parameters: + "up_large", "down_large", "up_small", or "down_small". If the scrollbar is dragged, + the callback will be called with the value that ``top_elem`` should be set to on + the next call to ``update()`` (see below). + +The Scrollbar widget implements the following methods: + +* ``scrollbar:update(top_elem, elems_per_page, num_elems)`` + + Updates the info about the widget that the scrollbar is paired with. + The ``top_elem`` param is the (one-based) index of the first visible element. + The ``elems_per_page`` param is the maximum number of elements that can be + shown at one time. The ``num_elems`` param is the total number of elements + that the paired widget can scroll through. If ``elems_per_page`` or + ``num_elems`` is not specified, the most recently specified value for these + parameters is used. The scrollbar will adjust its scrollbar size and position + according to the values passed to this function. + +Clicking on the arrows at the top or the bottom of a scrollbar will scroll an +associated widget by a small amount. Clicking on the unfilled portion of the +scrollbar above or below the filled area will scroll by a larger amount in that +direction. The amount of scrolling done in each case in determined by the +associated widget, and after scrolling is complete, the associated widget must +call ``scrollbar:update()`` with updated new display info. + +If the mouse wheel is scrolled while the mouse is over the Scrollbar widget's +parent view, then the parent is scrolled accordingly. Holding :kbd:`Shift` +while scrolling will result in faster movement. + +You can click and drag the scrollbar to scroll to a specific spot, or you can +click and hold on the end arrows or in the unfilled portion of the scrollbar to +scroll multiple times, just like in a normal browser scrollbar. The speed of +scroll events when the mouse button is held down can be controlled +via the `control-panel` or `gui/control-panel` interfaces: + +1. The delay before the second scroll event is the ``Mouse initial scroll repeat + delay`` setting (default is 300 ms) + +2. The delay between further scroll events is the ``Mouse scroll repeat delay`` option + (default is 20 ms) + +Label class +----------- + +This Widget subclass implements flowing semi-static text. + +It has the following attributes: + +:text_pen: Specifies the pen for active text. +:text_dpen: Specifies the pen for disabled text. +:text_hpen: Specifies the pen for text hovered over by the mouse, if a click + handler is registered. By default, this will invert the foreground and + background colors. +:disabled: Boolean or a callback; if true, the label is disabled. +:enabled: Boolean or a callback; if false, the label is disabled. +:auto_height: Sets self.frame.h from the text height. +:auto_width: Sets self.frame.w from the text width. +:on_click: A callback called when the label is clicked (optional) +:on_rclick: A callback called when the label is right-clicked (optional) +:scroll_keys: Specifies which keys the label should react to as a table. The + table should map keys to the number of lines to scroll as positive or + negative integers or one of the keywords supported by the ``scroll`` + method. The default is up/down arrows scrolling by one line and page + up/down scrolling by one page. + +``text_pen``, ``text_dpen``, and ``text_hpen`` can either be a pen or a +function that dynamically returns a pen. + +The text itself is represented as a complex structure, and passed +to the object via the ``text`` argument of the constructor, or via +the ``setText`` method, as one of: + +* A simple string, possibly containing newlines. +* A sequence of tokens. + +Every token in the sequence in turn may be either a string, possibly +containing newlines (or equal to ``NEWLINE``), or a table with the following +possible fields: + +* ``token.text = ...`` + + Specifies the main text content of a token, and may be a string, or + a callback returning a string. + +* ``token.gap = ...`` + + Specifies the number of character positions to advance on the line + before rendering the token. + +* ``token.tile``, ``token.htile`` + + Specifies a pen or texture index (or a function that returns a pen or texture + index) to paint as one tile before the main part of the token. If ``htile`` + is specified, that is used instead of ``tile`` when the Label is hovered over + with the mouse. + +* ``token.width = ...`` + + If specified either as a value or a callback, the text (or tile) field is + padded or truncated to the specified number. + +* ``token.pad_char = '?'`` + + If specified together with ``width``, the padding area is filled with + this character instead of just being skipped over. + +* ``token.key = '...'`` + + Specifies the keycode associated with the token. The string description + of the key binding is added to the text content of the token. + +* ``token.key_sep = '...'`` + + Specifies the separator to place between the keybinding label produced + by ``token.key``, and the main text of the token. If the separator starts with + '()', the token is formatted as ``text..' ('..binding..sep:sub(2)``. Otherwise + it is simply ``binding..sep..text``. + +* ``token.enabled``, ``token.disabled`` + + Same as the attributes of the label itself, but applies only to the token. + +* ``token.pen``, ``token.dpen``, ``token.hpen`` + + Specify the pen, disabled pen, and hover pen to be used for the token's text. + The fields may be either the pen itself, or a callback that returns it. + +* ``token.on_activate`` + + If this field is not nil, and ``token.key`` is set, the token will actually + respond to that key binding unless disabled, and call this callback. Eventually + this may be extended with mouse click support. + +* ``token.id`` + + Specifies a unique identifier for the token. + +* ``token.line``, ``token.x1``, ``token.x2`` + + Reserved for internal use. + +The Label widget implements the following methods: + +* ``label:setText(new_text)`` + + Replaces the text currently contained in the widget. + +* ``label:itemById(id)`` + + Finds a token by its ``id`` field. + +* ``label:getTextHeight()`` + + Computes the height of the text. + +* ``label:getTextWidth()`` + + Computes the width of the text. + +* ``label:scroll(nlines)`` + + This method takes the number of lines to scroll as positive or negative + integers or one of the following keywords: ``+page``, ``-page``, + ``+halfpage``, ``-halfpage``, ``home``, or ``end``. It returns the number of + lines that were actually scrolled (negative for scrolling up). + +* ``label:shouldHover()`` + + This method returns whether or not this widget should show a hover effect, + generally you want to return ``true`` if there is some type of mouse handler + present. For example, for a ``HotKeyLabel``:: + + function HotkeyLabel:shouldHover() + -- When on_activate is set, text should also hover on mouseover + return HotkeyLabel.super.shouldHover(self) or self.on_activate + end + +The widgets module also provides the following methods for help in constructing +common text token lists that you can then pass as ``text`` to a ``Label``: + +* ``makeButtonLabelText(spec)`` + + Returns a list of ``Label`` text tokens that represent a button according + to the given ``spec``, which is a table with the following fields. Fields + that contain ``_hover`` are optional and specify alternate values to be + used when the mouse cursor is hovering over the button. + + - ``chars``, ``chars_hover``: A list of strings or a list of lists of + characters. These strings (or lists of characters) make up the ASCII + representation of the button. If a list of strings is passed, each + string must be the same length. ``chars`` is the only required element + in the spec. If ``chars_hover`` is not specified, it defaults to the + value of ``chars``. + + - ``pens``, ``pens_hover``: A color or a pen or a list of lists of colors + or pens. This controls what color and other pen properties should be + applied to the corresponding button tile position. If a single color or + pen is passed, then that color or pen will apply to all tiles of the + button. If not specified, ``pens`` defaults to ``COLOR_GRAY`` and + ``pens_hover`` defaults to ``COLOR_WHITE`` + + - ``tileset``, ``tileset_hover``: If specified, must be a tileset that was + returned from ``dfhack.textures.loadTileset``. + + - ``tileset_offset``, ``tileset_hover_offset``: The 1-based offset within + the tileset to the tile that represents the upper left corner of the + button. If not specified, defaults to ``1``. + + - ``tileset_stride``, ``tileset_hover_stride``: The number of tiles in one + row of the tileset. This is used to find the start position of + subsequent rows of tiles for the button. If not specified, defaults to + the width of a button row specified in ``chars``, which is appropriate + for a tileset that has only a single button image per logical row. + + - ``asset``, ``asset_hover``: If specified, must be a table defining a + graphic asset loaded by DF from the vanilla sprite sheets or a mod. The + table must indicate which sprite page to read and the x and y offsets + of the upper left corner of the target asset in the following format: + ``{page=pagename, x=x_offset, y=y_offset}``. + + - ``tiles_override``, ``tiles_hover_override``: A list of lists of integers + representing raw tile texpos values to be displayed at the + corresponding button position. Tiles specified here will override + corresponding tiles from ``tileset`` and ``asset``. The lists can be + sparse, so any unspecified values in the override array will fall + through to other specifiers. + + If no tile is set for a particular button position, the corresponding + pen is used without setting a ``tile`` value. + + Example 1: The civ-alert button - a text-only (no graphic tiles) button + that highlights the text on hover:: + + widgets.Label{ + text=widgets.makeButtonLabelText{ + chars={ + ' Activate ', + ' civilian ', + ' alert ', + }, + pens={fg=COLOR_BLACK, bg=COLOR_LIGHTRED}, + pens_hover={fg=COLOR_WHITE, bg=COLOR_RED}, + }, + on_click=sound_alarm, + }, + + Example 2: The DFHack logo - a graphical button in graphics mode and a text + button in ASCII mode. The ASCII colors use the default for hovering:: + + local logo_textures=dfhack.textures.loadTileset( + 'hack/data/art/logo.png', 8, 12, true), + widgets.Label{ + text=widgets.makeButtonLabelText{ + chars={ + {179, 'D', 'F', 179}, + {179, 'H', 'a', 179}, + {179, 'c', 'k', 179}, + }, + tileset=logo_textures, + tileset_offset=1, + tileset_stride=8, + tileset_hover=logo_textures, + tileset_hover_offset=5, + tileset_hover_stride=8, + }, + on_click=function() + dfhack.run_command{'hotkeys', 'menu', self.name} + end, + }, + + Example 3: One of the warm/damp toolbar buttons - similar to example 2, but + with custom colors throughout the button when in ASCII mode:: + + widgets.Label{ + text=widgets.makeButtonLabelText{ + chars={ + {218, 196, 196, 191}, + {179, '~', '~', 179}, + {192, 196, 196, 217}, + }, + pens={ + {COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE}, + {COLOR_WHITE, COLOR_RED, COLOR_GRAY, COLOR_WHITE}, + {COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE}, + }, + tileset=toolbar_textures, + tileset_offset=25, + tileset_stride=8, + }, + on_click=launch_warm_damp_dig_config, + }, + + Example 4: A copy of the mining toolbar button (except that it has a + highlight on hover), loaded from the DF assets:: + + widgets.Label{ + text=widgets.makeButtonLabelText{ + chars={ + {218, 196, 196, 191}, + {179, '-', ')', 179}, + {192, 196, 196, 217}, + }, + pens={ + {COLOR_GRAY, COLOR_GRAY, COLOR_GRAY, COLOR_GRAY}, + {COLOR_GRAY, COLOR_BROWN, COLOR_GRAY, COLOR_GRAY}, + {COLOR_GRAY, COLOR_GRAY, COLOR_GRAY, COLOR_GRAY}, + }, + pens_hover={ + {COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE}, + {COLOR_WHITE, COLOR_BROWN, COLOR_GRAY, COLOR_WHITE}, + {COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE}, + }, + asset={page='INTERFACE_BITS', x=0, y=22}, + }, + on_click=self:callback('mining_menu'), + }, + + Example 5: A copy of the mining toolbar button (except that it has a + custom hotkey hint in the upper corner), loaded from the DF assets and with + one tile overridden:: + + widgets.Label{ + text=widgets.makeButtonLabelText{ + chars={ + {218, 196, 196, self.hint_char}, + {179, '-', ')', 179}, + {192, 196, 196, 217}, + }, + pens={ + {COLOR_GRAY, COLOR_GRAY, COLOR_GRAY, COLOR_RED}, + {COLOR_GRAY, COLOR_BROWN, COLOR_GRAY, COLOR_GRAY}, + {COLOR_GRAY, COLOR_GRAY, COLOR_GRAY, COLOR_GRAY}, + }, + asset={page='INTERFACE_BITS', x=0, y=22}, + tiles_override={{[4]=string.byte(self.hint_char)}}, + }, + on_click=self:callback('mining_menu'), + }, + +WrappedLabel class +------------------ + +This Label subclass represents text that you want to be able to dynamically +wrap. This frees you from having to pre-split long strings into multiple lines +in the Label ``text`` list. + +It has the following attributes: + +:text_to_wrap: The string (or a table of strings or a function that returns a + string or a table of strings) to display. The text will be autowrapped to + the width of the widget, though any existing newlines will be kept. +:indent: The number of spaces to indent the text from the left margin. The + default is ``0``. + +The displayed text is refreshed and rewrapped whenever the widget bounds change. +To force a refresh (to pick up changes in the string that ``text_to_wrap`` +returns, for example), all ``updateLayout()`` on this widget or on a widget that +contains this widget. + +TooltipLabel class +------------------ + +This WrappedLabel subclass represents text that you want to be able to +dynamically hide, like help text in a tooltip. + +It has the following attributes: + +:show_tooltip: Boolean or a callback; if true, the widget is visible. + +The ``text_pen`` attribute of the ``Label`` class is overridden with a default +of ``COLOR_GREY`` and the ``indent`` attribute of the ``WrappedLabel`` class is +overridden with a default of ``2``. + +The text of the tooltip can be passed in the inherited ``text_to_wrap`` +attribute so it can be autowrapped, or in the basic ``text`` attribute if no +wrapping is required. + +HotkeyLabel class +----------------- + +This Label subclass is a convenience class for formatting text that responds to +a hotkey or mouse click. + +It has the following attributes: + +:key: The hotkey keycode to display, e.g., ``'CUSTOM_A'``. +:key_sep: If specified, will be used to customize how the activation key is + displayed. See ``token.key_sep`` in the ``Label`` documentation. +:label: The string (or a function that returns a string) to display after the + hotkey. +:on_activate: If specified, it is the callback that will be called whenever + the hotkey is pressed or the label is clicked. + +The HotkeyLabel widget implements the following methods: + +* ``hotkeylabel:setLabel(label)`` + + Updates the label without altering the hotkey text. + +* ``hotkeylabel:setOnActivate(on_activate)`` + + Updates the on_activate callback. + +CycleHotkeyLabel class +---------------------- + +This Label subclass represents a group of related options that the user can +cycle through by pressing a specified hotkey or clicking on the text. + +It has the following attributes: + +:key: The hotkey keycode to display, e.g., ``'CUSTOM_A'``. +:key_back: Similar to ``key``, but will cycle backwards (optional) +:key_sep: If specified, will be used to customize how the activation key is + displayed. See ``token.key_sep`` in the ``Label`` documentation. +:label: The string (or a function that returns a string) to display after the + hotkey. +:label_width: The number of spaces to allocate to the ``label`` (for use in + aligning a column of ``CycleHotkeyLabel`` labels). +:label_below: If ``true``, then the option value will appear below the label + instead of to the right of it. Defaults to ``false``. +:option_gap: The size of the gap between the label text and the option value. + Default is ``1``. If set to ``0``, there'll be no gap between the strings. + If ``label_below`` == ``true``, negative values will shift the value leftwards. +:options: A list of strings or tables of + ``{label=string or fn, value=val[, pen=pen]}``. String options use the same + string for the label and value and use the default pen. The optional ``pen`` + element could be a color like ``COLOR_RED``. +:initial_option: The value or numeric index of the initial option. +:on_change: The callback to call when the selected option changes. It is called + as ``on_change(new_option_value, old_option_value)``. + +The index of the currently selected option in the ``options`` list is kept in +the ``option_idx`` instance variable. + +The CycleHotkeyLabel widget implements the following methods: + +* ``cyclehotkeylabel:cycle([backwards])`` + + Cycles the selected option and triggers the ``on_change`` callback. + If ``backwards`` is defined and is truthy, the cycle direction will be reversed + +* ``cyclehotkeylabel:setOption(value_or_index, call_on_change)`` + + Sets the current option to the option with the specified value or + index. If ``call_on_change`` is set to ``true``, then the ``on_change`` + callback is triggered. + +* ``cyclehotkeylabel:getOptionLabel([option_idx])`` + + Retrieves the option label at the given index, or the label of the + currently selected option if no index is given. + +* ``cyclehotkeylabel:getOptionValue([option_idx])`` + + Retrieves the option value at the given index, or the value of the + currently selected option if no index is given. + +* ``cyclehotkeylabel:getOptionPen([option_idx])`` + + Retrieves the option pen at the given index, or the pen of the currently + selected option if no index is given. If an option was defined as just a + string, then this function will return ``nil`` for that option. + +ButtonGroup class +----------------- + +This is a specialized subclass of CycleHotkeyLabel that, in addition to the +regular clickable widget, displays a corresponding row of clickable graphical +buttons and synchronizes their selection state with the currently selected +option. + +It takes two additional required parameters to define the buttons: + +:button_specs: A list of specs to pass to ``makeButtonLabelText`` (defined in + `Label class`_ above). +:button_specs_selected: A list of specs that represent the buttons in their + selected state. + +ToggleHotkeyLabel class +----------------------- + +This is a specialized subclass of CycleHotkeyLabel that has two options: +``On`` (with a value of ``true``) and ``Off`` (with a value of ``false``). The +``On`` option is rendered in green. + +ConfigureButton class +--------------------- + +A 3x1 tile button with a gear symbol on it, intended to represent a configure +icon. Clicking on the icon will run the given callback. The graphics can also +be overridden to create custom buttons. + +It has the following attributes: + +:on_click: The function to run when the icon is clicked. +:pen_left: Pen or function returning a pen to overwrite the left tile of the button. +:pen_center: As above, but for the center tile (gear symbol). +:pen_right: As above, but for the right tile. + +HelpButton class +---------------- + +Subclass of ConfigureButton; a 3x1 tile button with a question mark on it, +intended to represent a help icon. Clicking on the icon will launch +`gui/launcher` with a given command string, showing the help text for that +command. + +It has the following attributes: + +:command: The command to load in `gui/launcher`. + +It also sets the ``frame`` attribute so the button appears in the upper right +corner of the parent, but you can override this to your liking if you want a +different position. + +RadioButton class +----------------- + +Subclass of ConfigureButton; a 3x1 tile button that resembles a radio button +(or check box in ASCII mode), identical to the ones found in +`gui/control-panel`. Clicking on the button will toggle its enabled state. + +It has the following attributes: + +:initial_state: Whether to start in the ``true`` or ``false`` state. Defaults to ``true``. +:on_change: Callback to call when state changes, including initialization. Called as ``on_change(val)``. + +It implements the following method: + +* ``RadioButton:setState(val)`` + + Sets the state to boolean ``val`` and calls ``on_change`` (if defined). + +BannerPanel class +----------------- + +This is a Panel subclass that prints a distinctive banner along the far left +and right columns of the widget frame. Note that this is not a "proper" frame +since it doesn't have top or bottom borders. Subviews of this panel should +inset their frames one tile from the left and right edges. + +TextButton class +---------------- + +This is a BannerPanel subclass that wraps a HotkeyLabel with some decorators on +the sides to make it look more like a button, suitable for both graphics and +ASCII modes. All HotkeyLabel parameters passed to the constructor are passed +through to the wrapped HotkeyLabel. + +List class +---------- + +The List widget implements a simple list with paging. You can click on a list +item to call the ``on_submit`` callback for that item. + +It has the following attributes: + +:text_pen: Specifies the pen for deselected list entries. +:text_hpen: Specifies the pen for entries that the mouse is hovered over. + Defaults to swapping the background/foreground colors. +:cursor_pen: Specifies the pen for the selected entry. +:inactive_pen: If specified, used for the cursor when the widget is not active. +:icon_pen: Default pen for icons. +:on_select: Selection change callback; called as ``on_select(index,choice)``. + This is also called with *nil* arguments if ``setChoices`` is called + with an empty list. +:on_submit: Enter key or mouse click callback; if specified, the list reacts to the + key/click and calls the callback as ``on_submit(index,choice)``. +:on_submit2: Shift-click callback; if specified, the list reacts to the click and + calls the callback as ``on_submit2(index,choice)``. +:on_double_click: Mouse double click callback; if specified, the list reacts to the + click and calls the callback as ``on_double_click(index,choice)``. +:on_double_click2: Shift-double click callback; if specified, the list reacts to the + click and calls the callback as ``on_double_click2(index,choice)``. +:row_height: Height of every row in text lines. +:icon_width: If not *nil*, the specified number of character columns + are reserved to the left of the list item for the icons. +:scroll_keys: Specifies which keys the list should react to as a table. + +Every list item may be specified either as a string, or as a lua table +with the following fields: + +:text: Specifies the label text in the same format as the Label text. +:text_*: Reserved for internal use. +:key: Specifies a keybinding that acts as a shortcut for the specified item. +:icon: Specifies an icon string, or a pen to paint a single character. May be a callback. +:icon_pen: When the icon is a string, used to paint it. + +The list supports the following methods: + +* ``List{ ..., choices = ..., selected = ... }`` + + Same as calling ``setChoices`` after construction. + +* ``list:setChoices(choices[, selected])`` + + Replaces the list of choices, possibly also setting the currently selected index. + +* ``list:setSelected(selected)`` + + Sets the currently selected index. Returns the index after validation. + +* ``list:getChoices()`` + + Returns the list of choices. + +* ``list:getSelected()`` + + Returns the selected *index, choice*, or nothing if the list is empty. + +* ``list:getIdxUnderMouse()`` + + Returns the index of the list item under the mouse cursor, or nothing if the + list is empty or the mouse is not over a list item. + +* ``list:getContentWidth()`` + + Returns the minimal width to draw all choices without clipping. + +* ``list:getContentHeight()`` + + Returns the minimal width to draw all choices without scrolling. + +* ``list:submit()`` + + Call the ``on_submit`` callback, as if the Enter key was handled. + +* ``list:submit2()`` + + Call the ``on_submit2`` callback, as if the Shift-Enter key was handled. + +FilteredList class +------------------ + +This widget combines List, EditField and Label into a combo-box like +construction that allows filtering the list. + +In addition to passing through all attributes supported by List, it +supports: + +:edit_pen: If specified, used instead of ``cursor_pen`` for the edit field. +:edit_below: If true, the edit field is placed below the list instead of above. +:edit_key: If specified, the edit field is disabled until this key is pressed. +:edit_ignore_keys: If specified, will be passed to the filter edit field as its ``ignore_keys`` attribute. +:edit_on_change: If specified, will be passed to the filter edit field as its ``on_change`` attribute. +:edit_on_char: If specified, will be passed to the filter edit field as its ``on_char`` attribute. +:not_found_label: Specifies the text of the label shown when no items match the filter. + +The list choices may include the following attributes: + +:search_key: If specified, used instead of **text** to match against the filter. + Can be a string or a function that returns a string. + +The widget implements: + +* ``list:setChoices(choices[, selected])`` + + Resets the filter, and passes through to the inner list. + +* ``list:getChoices()`` + + Returns the list of *all* choices. + +* ``list:getVisibleChoices()`` + + Returns the *filtered* list of choices. + +* ``list:getFilter()`` + + Returns the current filter string, and the *filtered* list of choices. + +* ``list:setFilter(filter[,pos])`` + + Sets the new filter string, filters the list, and selects the item at + index ``pos`` in the *unfiltered* list if possible. + +* ``list:canSubmit()`` + + Checks if there are currently any choices in the filtered list. + +* ``list:getSelected()``, ``list:getContentWidth()``, ``list:getContentHeight()``, ``list:submit()`` + + Same as with an ordinary list. + +Filter behavior: + +By default, the filter matches substrings that start at the beginning of a word +(or after any punctuation). You can instead configure filters to match any +substring across the full text by setting ``FILTER_FULL_TEXT`` in `gui/control-panel` +or set it for the session by running a command like:: + + :lua require('utils').FILTER_FULL_TEXT=true + +TabBar class +------------ + +This widget implements a set of one or more tabs to allow navigation between groups +of content. + +:wrap: If true, tabs automatically wrap on the width of the window and will + continue rendering on the next line(s) if all tabs cannot fit on a single line. + If false, tabs will be truncated and can be scrolled using ``scroll_key`` + and ``scroll_key_back``, mouse wheel or by clicking on the scroll labels + that will automatically appear on the left and right sides of the tab bar + as needed. When clicking on a tab or using ``key`` or ``key_back`` to switch tabs, + the selected tab will be scrolled into view if it is not already visible. + Defaults to true. +:key: Specifies a keybinding that can be used to switch to the next tab. + Defaults to ``CUSTOM_CTRL_T``. +:key_back: Specifies a keybinding that can be used to switch to the previous + tab. Defaults to ``CUSTOM_CTRL_Y``. +:labels: A table of strings; entry representing the label text for a single tab. + The order of the entries determines the order the tabs will appear in. +:on_select: Callback executed when a tab is selected. It receives the selected tab + index as an argument. The provided function should update the value of + whichever variable your script uses to keep track of the currently + selected tab. +:get_cur_page: The function used by the TabBar to determine which Tab is currently + selected. The function you provide should return an integer that + corresponds to the non-zero index of the currently selected Tab + (i.e., whatever variable you update in your ``on_select`` callback). +:active_tab_pens: A table of pens used to render active tabs. See the default + implementation in widgets.lua for an example of how to construct + the table. Leave unspecified to use the default pens. +:inactive_tab_pens: A table of pens used to render inactive tabs. See the default + implementation in widgets.lua for an example of how to + construct the table. Leave unspecified to use the default pens. +:get_pens: A function used to determine which pens should be used to render a tab. + Receives the index of the tab as the first argument and the TabBar widget + itself as the second. The default implementation, which will handle most + situations, returns ``self.active_tab_pens``, if ``self.get_cur_page() == idx``, + otherwise returns ``self.inactive_tab_pens``. +:scroll_key: Specifies a keybinding that can be used to scroll the tabs to the right. + Defaults to ``CUSTOM_ALT_T``. +:scroll_key_back: Specifies a keybinding that can be used to scroll the tabs to the left. + Defaults to ``CUSTOM_ALT_Y``. +:scroll_left_text: The text to display on the left scroll label. + Defaults to "<<<". +:scroll_right_text: The text to display on the right scroll label. + Defaults to ">>>". +:scroll_label_text_pen: The pen to use for the scroll label text. + Defaults to ``Label`` default. +:scroll_label_text_hpen: The pen to use for the scroll label text when hovered. + Defaults to ``scroll_label_text_pen`` with the background + and foreground colors swapped. +:scroll_step: The number of units to scroll tabs by. + Defaults to 10. +:fast_scroll_multiplier: The multiplier for fast scrolling (holding shift). + Defaults to 3. +:scroll_into_view_offset: After a selected tab is scrolled into view, this offset + is added to the scroll position to ensure the tab is + not flush against the edge of the tab bar, allowing + some space for the user to see the next tab. + Defaults to 5. + +Tab class +--------- + +This widget implements a single clickable tab and is the main component of the TabBar +widget. Usage of the ``TabBar`` widget does not require direct usage of ``Tab``. + +:id: The id of the tab. +:label: The text displayed on the tab. +:on_select: Callback executed when the tab is selected. +:get_pens: A function that is used during ``Tab:onRenderBody`` to determine the pens + that should be used for drawing. See the usage of ``Tab`` in + ``TabBar:init()`` for an example. See the default value of + ``active_tab_pens`` or ``inactive_tab_pens`` in ``TabBar`` + for an example of how to construct pens. + +RangeSlider class +----------------- + +This widget implements a mouse-interactable range-slider. The player can move its two +handles to set minimum and maximum values to define a range, or they can drag the bar +itself to move both handles at once. The parent widget owns the range values, and can +control them independently (e.g., with ``CycleHotkeyLabels``). If the range values +change, the ``RangeSlider`` appearance will adjust automatically. + +:num_stops: Used to specify the number of "notches" in the range slider, the places + where handles can stop. (This should match the parents' number of options.) +:get_left_idx_fn: The function used by the RangeSlider to get the notch index on which + to display the left handle. +:get_right_idx_fn: The function used by the RangeSlider to get the notch index on which + to display the right handle. +:on_left_change: Callback executed when moving the left handle. +:on_right_change: Callback executed when moving the right handle. + +Slider class +----------------- + +This widget implements a mouse-interactable slider. The player can move the handle to +set the value of the slider. The parent widget owns the slider value, and can control +it independently (e.g., with a ``CycleHotkeyLabel``). If the value changes, the ``Slider`` +appearance will adjust automatically. + +:num_stops: Used to specify the number of "notches" in the slider, the places + where the handle can stop. (This should match the parents' number of options.) +:get_idx_fn: The function used by the Slider to get the notch index on which + to display the handle. +:on_change: Callback executed when moving the handle. + +DimensionsTooltip class +----------------------- + +This widget follows the mouse cursor around and displays a string that +indicates selected 3d dimensions. It is intended to be a child widget of a +full-screen ``View``, such as a ``ZScreen``. + +:display_offset: the offset from the mouse cursor where the tooltip is + displayed. Positive offsets are down and to the right. Defaults to + ``{x=3, y=3}``. +:get_anchor_pos_fn: function that provides the other corner of the selected + area as a ``df.coord``-style table, that is, a table with ``x``, ``y``, and + ``z`` fields. Must return ``nil`` if there is no current selection. + +gui.textures +============ + +This module contains convenience methods for accessing default DFHack graphic assets. +Pass the ``offset`` in tiles (in row major position) to get a particular tile from the +asset. ``offset`` 0 is the first tile. + +* ``tp_green_pin(offset)`` tileset: ``hack/data/art/green-pin.png`` +* ``tp_red_pin(offset)`` tileset: ``hack/data/art/red-pin.png`` +* ``tp_icons(offset)`` tileset: ``hack/data/art/icons.png`` +* ``tp_on_off(offset)`` tileset: ``hack/data/art/on-off.png`` +* ``tp_control_panel(offset)`` tileset: ``hack/data/art/control-panel.png`` +* ``tp_border_thin(offset)`` tileset: ``hack/data/art/border-thin.png`` +* ``tp_border_medium(offset)`` tileset: ``hack/data/art/border-medium.png`` +* ``tp_border_bold(offset)`` tileset: ``hack/data/art/border-bold.png`` +* ``tp_border_panel(offset)`` tileset: ``hack/data/art/border-panel.png`` +* ``tp_border_window(offset)`` tileset: ``hack/data/art/order-window.png`` + +Example usage:: + + local textures = require('gui.textures') + local first_border_texpos = textures.tp_border_thin(1) + + +.. _lua-plugins: + +======= +Plugins +======= + +.. contents:: + :local: + +DFHack plugins may export native functions and events to Lua contexts. These are +exposed as ``plugins.`` modules, which can be imported with +``require('plugins.')``. The plugins listed in this section expose +functions and/or data to Lua in this way. + +In addition to any native functions documented here, plugins that can be +enabled (that is, plugins that support the `enable/disable API `) will +have the following functions defined: + +* ``isEnabled()`` returns whether the plugin is enabled. +* ``setEnabled(boolean)`` sets whether the plugin is enabled. + +For plugin developers, note that a Lua file in ``plugins/lua`` is required for +``require()`` to work, even if it contains no pure-Lua functions. This file must +contain ``mkmodule('plugins.')`` to import any native functions defined in +the plugin. See existing files in ``plugins/lua`` for examples. + +blueprint +========= + +Lua functions provided by the `blueprint` plugin to programmatically generate +blueprint files: + +* ``dig(start, end, name)`` +* ``build(start, end, name)`` +* ``place(start, end, name)`` +* ``query(start, end, name)`` + + ``start`` and ``end`` are tables containing positions (see ``xyz2pos``). + ``name`` is used as the basis for the generated filenames. + +The names of the functions are also available as the keys of the +``valid_phases`` table. + +.. _building-hacks-api: + +building-hacks +============== + +This plugin overwrites some methods in workshop df class so that mechanical workshops are +possible. Although plugin export a function it's recommended to use lua decorated function. + +.. contents:: + :local: + +Functions +--------- + +``registerBuilding(table)`` where table must contain name, as a workshop raw name, +the rest are optional: + + :name: + custom workshop id e.g., ``SOAPMAKER`` + + .. note:: this is the only mandatory field. + + :fix_impassible: + if true make impassable tiles impassable to liquids too + :consume: + how much machine power is needed to work. + Disables reactions if not supplied enough and ``needs_power==1`` + :produce: + how much machine power is produced. + :needs_power: + if produced in network < consumed stop working, default true + :gears: + a table or ``{x=?,y=?}`` of connection points for machines. + :action: + a table of number (how much ticks to skip) and a function which + gets called on shop update + :animate: + a table of frames which can be a table of: + + a. tables of 4 numbers ``{tile,fore,back,bright}`` OR + b. empty table (tile not modified) OR + c. ``{x= y= + 4 numbers like in first case}``, + this generates full frame useful for animations that change little (1-2 tiles) + + :canBeRoomSubset: + a flag if this building can be counted in room. 1 means it can, + 0 means it can't and -1 default building behaviour + :auto_gears: + a flag that automatically fills up gears and animations. + It looks over the building definition for gear icons and maps them. + + Animate table also might contain: + + :frameLength: + how many ticks does one frame take OR + :isMechanical: + a bool that says to try to match to mechanical system (i.e., how gears are turning) + +``getPower(building)`` returns two number - produced and consumed power if building can be +modified and returns nothing otherwise + +``setPower(building,produced,consumed)`` sets current power production and +consumption for a building. + +Examples +-------- + +Simple mechanical workshop:: + + require('plugins.building-hacks').registerBuilding{name="BONE_GRINDER", + consume=15, + gears={x=0,y=0}, --connection point + animate={ + isMechanical=true, --animate the same conn. point as vanilla gear + frames={ + {{x=0,y=0,42,7,0,0}}, --first frame, 1 changed tile + {{x=0,y=0,15,7,0,0}} -- second frame, same + } + } + +Or with auto_gears:: + + require('plugins.building-hacks').registerBuilding{name="BONE_GRINDER", + consume=15, + auto_gears=true + } + +buildingplan +============ + +Native functions provided by the `buildingplan` plugin: + +* ``bool isPlannableBuilding(df::building_type type, int16_t subtype, int32_t custom)`` + + Returns whether the building type is handled by buildingplan. + +* ``bool isPlanModeEnabled(df::building_type type, int16_t subtype, int32_t custom)`` + + Returns whether the buildingplan UI is enabled for the specified building type. + +* ``bool isPlannedBuilding(df::building *bld)`` + + Returns whether the given building is managed by buildingplan. + +* ``void addPlannedBuilding(df::building *bld)`` + + Suspends the building jobs and adds the building to the monitor list. + +* ``void doCycle()`` + + Runs a check for whether buildings in the monitor list can be assigned + items and unsuspended. This method runs automatically twice a game day, + so you only need to call it directly if you want buildingplan to do a + check right now. + +* ``void scheduleCycle()`` + + Schedules a cycle to be run during the next non-paused game frame. + Can be called multiple times while the game is paused and only one + cycle will be scheduled. + +.. _cxxrandom-api: + +cxxrandom +========= + +Exposes some features of the C++11 random number library to Lua. + +.. contents:: + :local: + +Native functions (exported to Lua) +---------------------------------- + +- ``GenerateEngine(seed)`` + + returns engine id + +- ``DestroyEngine(rngID)`` + + destroys corresponding engine + +- ``NewSeed(rngID, seed)`` + + re-seeds engine + +- ``rollInt(rngID, min, max)`` + + generates random integer + +- ``rollDouble(rngID, min, max)`` + + generates random double + +- ``rollNormal(rngID, avg, stddev)`` + + generates random double drawn from a normal (Gaussian) distribution + +- ``rollBool(rngID, chance)`` + + generates random boolean + +- ``MakeNumSequence(start, end)`` + + returns sequence id + +- ``AddToSequence(seqID, num)`` + + adds a number to the sequence + +- ``ShuffleSequence(seqID, rngID)`` + + shuffles the number sequence + +- ``NextInSequence(seqID)`` + + returns the next number in sequence + + +Lua plugin functions +-------------------- + +- ``MakeNewEngine(seed)`` + + returns engine id + +Lua plugin classes +------------------ + +crng +~~~~ + +- ``init(id, df, dist)``: constructor + + - ``id``: Reference ID of engine to use in RNGenerations. + - ``df`` (optional): bool indicating whether to destroy the Engine + when the crng object is garbage collected. + - ``dist`` (optional): lua number distribution to use. + +- ``changeSeed(seed)``: alters engine's seed value +- ``setNumDistrib(distrib)``: sets the number distribution crng object should use. + + - ``distrib``: number distribution object to use in RNGenerations. + +- ``next()``: returns the next number in the distribution. +- ``shuffle()``: effectively shuffles the number distribution. + +normal_distribution +~~~~~~~~~~~~~~~~~~~ + +- ``init(avg, stddev)``: constructor +- ``next(id)``: returns next number in the distribution + + - ``id``: engine ID to pass to native function + +real_distribution +~~~~~~~~~~~~~~~~~ + +- ``init(min, max)``: constructor +- ``next(id)``: returns next number in the distribution + + - ``id``: engine ID to pass to native function + +int_distribution +~~~~~~~~~~~~~~~~ + +- ``init(min, max)``: constructor +- ``next(id)``: returns next number in the distribution + + - ``id``: engine ID to pass to native function + +bool_distribution +~~~~~~~~~~~~~~~~~ + +- ``init(chance)``: constructor +- ``next(id)``: returns next boolean in the distribution + + - ``id``: engine ID to pass to native function + +num_sequence +~~~~~~~~~~~~ + +- ``init(a, b)``: constructor +- ``add(num)``: adds num to the end of the number sequence +- ``shuffle()``: shuffles the sequence of numbers +- ``next()``: returns next number in the sequence + +Usage +----- + +The randomization state is kept in an "engine". The distribution class turns +that engine state into random numbers. + +Example:: + + local rng = require('plugins.cxxrandom') + local norm_dist = rng.normal_distribution(6820, 116) -- avg, stddev + local engID = rng.MakeNewEngine(0) + print(norm_dist:next(engID)) + + -- alternate syntax + local cleanup = true -- delete engine on cleanup + local number_generator = rng.crng:new(engID, cleanup, norm_dist) + print(number_generator:next()) + + -- simplified + print(rng.rollNormal(engID, 6820, 116)) + +The number sequences are much simpler. They're intended for where you need to +randomly generate an index, perhaps in a loop for an array. You technically +don't need an engine to use it, if you don't mind never shuffling. + +Example:: + + local rng = require('plugins.cxxrandom') + local engID = rng.MakeNewEngine(0) + local g = rng.crng:new(engId, true, rng.num_sequence:new(0, table_size)) + g:shuffle() + for _ = 1, table_size do + func(array[g:next()]) + end + + +dig-now +======= + +The dig-now plugin exposes the following functions to Lua: + +* ``dig_now_tile(pos)`` or ``dig_now_tile(x,y,z)``: Runs dig-now for the + specified tile coordinate. Default options apply, as if you were running the + command ``dig-now ``. See the `dig-now` documentation for details + on default settings. + +.. _eventful-api: + +eventful +======== + +This plugin exports some events to lua thus allowing to run lua functions +on DF world events. + +.. contents:: + :local: + +List of events +-------------- + +1. ``onReactionCompleting(reaction,reaction_product,unit,input_items,input_reagents,output_items,call_native)`` + + Is called once per reaction product, before the reaction has a chance to + call native code for item creation. Setting ``call_native.value=false`` + cancels further processing: no items are created and ``onReactionComplete`` + is not called. + +2. ``onReactionComplete(reaction,reaction_product,unit,input_items,input_reagents,output_items)`` + + Is called once per reaction product, when reaction finishes and has + at least one product. + +3. ``onItemContaminateWound(item,unit,wound,number1,number2)`` + + Is called when item tries to contaminate wound (e.g., stuck in). + +4. ``onProjItemCheckMovement(projectile)`` + + Is called when projectile moves. + +5. ``onProjItemCheckImpact(projectile,somebool)`` + + Is called when projectile hits something. + +6. ``onProjUnitCheckMovement(projectile)`` + + Is called when projectile moves. + +7. ``onProjUnitCheckImpact(projectile,somebool)`` + + Is called when projectile hits something. + +8. ``onWorkshopFillSidebarMenu(workshop,callnative)`` + + Is called when viewing a workshop in 'q' mode, to populate + reactions, useful for custom viewscreens for shops. + +9. ``postWorkshopFillSidebarMenu(workshop)`` + + Is called after calling (or not) native fillSidebarMenu(). + Useful for job button tweaking (e.g., adding custom reactions) + +.. _EventManager: + +Events from EventManager +------------------------ +These events are straight from EventManager module. Each of them first needs +to be enabled. See functions for more info. If you register a listener before +the game is loaded, be aware that no events will be triggered immediately +after loading, so you might need to add another event listener for when the +game first loads in some cases. + +1. ``onBuildingCreatedDestroyed(building_id)`` + + Gets called when building is created or destroyed. + +2. ``onConstructionCreatedDestroyed(building_id)`` + + Gets called when construction is created or destroyed. + +3. ``onJobInitiated(job)`` + + Gets called when job is issued. + +4. ``onJobCompleted(job)`` + + Gets called when job is finished. The job that is passed to this function + is a copy. Requires a frequency of 0 in order to distinguish between + workshop jobs that were canceled by the user and workshop jobs that + completed successfully. + +5. ``onUnitDeath(unit_id)`` + + Gets called on unit death. + +6. ``onItemCreated(item_id)`` + + Gets called when item is created (except due to traders, migrants, + invaders, and spider webs). + +7. ``onSyndrome(unit_id,syndrome_index)`` + + Gets called when new syndrome appears on a unit. + +8. ``onInvasion(invasion_id)`` + + Gets called when new invasion happens. + +9. ``onInventoryChange(unit_id,item_id,old_equip,new_equip)`` + + Gets called when someone picks up an item, puts one down, + or changes the way they are holding it. If an item is picked up, + old_equip will be null. If an item is dropped, new_equip will be null. + If an item is re-equipped in a new way, then neither will be null. + You absolutely must NOT alter either old_equip or new_equip or you + might break other plugins. + +10. ``onReport(reportId)`` + + Gets called when a report happens. This happens more often than + you probably think, even if it doesn't show up in the announcements. + +11. ``onUnitAttack(attackerId, defenderId, woundId)`` + + Called when a unit wounds another with a weapon. + Is NOT called if blocked, dodged, deflected, or parried. + +12. ``onUnload()`` + + A convenience event in case you don't want to register for every onStateChange event. + +13. ``onInteraction(attackVerb, defendVerb, attackerId, defenderId, attackReportId, defendReportId)`` + + Called when a unit uses an interaction on another. + +Functions +--------- + +1. ``registerReaction(reaction_name,callback)`` + + Simplified way of using onReactionCompleting; the callback is function (same params as event). + +2. ``removeNative(shop_name)`` + + Removes native choice list from the building. + +3. ``addReactionToShop(reaction_name,shop_name)`` + + Add a custom reaction to the building. + +4. ``enableEvent(evType,frequency)`` + + Enable event checking for EventManager events. For event types use ``eventType`` table. + Note that different types of events require different frequencies to be effective. The + frequency is how many ticks EventManager will wait before checking if that type of event + has happened. If multiple scripts or plugins use the same event type, the smallest frequency + is the one that is used, so you might get events triggered more often than the frequency + you use here. + +5. ``registerSidebar(shop_name,callback)`` + + Enable callback when sidebar for ``shop_name`` is drawn. Useful for custom workshop views, + e.g., using gui.dwarfmode lib. Also accepts a ``class`` instead of function as callback. + Best used with ``gui.dwarfmode`` class ``WorkshopOverlay``. + +Examples +-------- +Spawn dragon breath on each item attempt to contaminate wound:: + + b=require "plugins.eventful" + b.onItemContaminateWound.one=function(item,unit,un_wound,x,y) + local flw=dfhack.maps.spawnFlow(unit.pos,6,0,0,50000) + end + +Reaction complete example:: + + b=require "plugins.eventful" + + b.registerReaction("LAY_BOMB",function(reaction,unit,in_items,in_reag,out_items,call_native) + local pos=copyall(unit.pos) + -- spawn dragonbreath after 100 ticks + dfhack.timeout(100,"ticks",function() dfhack.maps.spawnFlow(pos,6,0,0,50000) end) + --do not call real item creation code + call_native.value=false + end) + +Grenade example:: + + b=require "plugins.eventful" + b.onProjItemCheckImpact.one=function(projectile) + -- you can check if projectile.item e.g., has correct material + dfhack.maps.spawnFlow(projectile.cur_pos,6,0,0,50000) + end + +Integrated tannery:: + + b=require "plugins.eventful" + b.addReactionToShop("TAN_A_HIDE","LEATHERWORKS") + +.. _luasocket-api: + +luasocket +========= + +A way to access csocket from lua. The usage is made similar to luasocket in +vanilla lua distributions. Currently only a subset of the functions exist +and only TCP mode is implemented. + +.. contents:: + :local: + +Socket class +------------ + +This is a base class for ``client`` and ``server`` sockets. You can not create +it - it's like a virtual base class in c++. + +* ``socket:close()`` + + Closes the connection. + +* ``socket:setTimeout(sec,msec)`` + + Sets the operation timeout for this socket. It's possible to set timeout to 0. + Then it performs like a non-blocking socket. + +Client class +------------ + +Client is a connection socket to a server. You can get this object either from +``tcp:connect(address,port)`` or from ``server:accept()``. +It's a subclass of ``socket``. + +* ``client:receive(pattern)`` + + Receives data. Pattern is one of: + + :``*l``: read one line (default, if pattern is *nil*) + :: read specified number of bytes + :``*a``: read all available data + +* ``client:send(data)`` + + Sends data. Data is a string. + + +Server class +------------ + +Server is a socket that is waiting for clients. +You can get this object from ``tcp:bind(address,port)``. + +* ``server:accept()`` + + Accepts an incoming connection if it exists. + Returns a ``client`` object representing that socket. + +Tcp class +--------- + +A class with all the tcp functionality. + +* ``tcp:bind(address,port)`` + + Starts listening on that port for incoming connections. + Returns ``server`` object. + +* ``tcp:connect(address,port)`` + + Tries connecting to that address and port. Returns ``client`` object. + + +.. _map-render-api: + +map-render +========== + +A way to ask DF to render a section of the fortress mode map. +This uses a native DF rendering function so it's highly dependent +on DF settings (e.g., tileset, colors, etc.) + +Functions +--------- + +- ``render_map_rect(x,y,z,w,h)`` + + Returns a table with w*h*4 entries of rendered tiles. The format is + the same as ``df.global.gps.screen`` (tile,foreground,bright,background). + +.. _pathable-api: + +pathable +======== + +This plugin implements the back end of the `gui/pathable` script. It exports a +single Lua function, in ``hack/lua/plugins/pathable.lua``: + +* ``paintScreen(cursor[,skip_unrevealed])``: Paint each visible of the screen + green or red, depending on whether it can be pathed to from the tile at + ``cursor``. If ``skip_unrevealed`` is specified and true, do not draw + unrevealed tiles. + +reveal +====== + +Native functions provided by the `reveal` plugin: + +* ``void unhideFlood(pos)``: Unhides map tiles according to visibility rules, + starting from the given coordinates. This algorithm only processes adjacent + hidden tiles, so it must start on a hidden tile in order to have any effect. + It will not reveal hidden sections separated by already-unhidden tiles. + +Example of revealing a cavern that happens to have an open tile at the specified +coordinate:: + + unhideFlood({x=25, y=38, z=140}) + +sort +==== + +The `sort ` plugin does not export any native functions as of now. +Instead, it calls Lua code to perform the actual ordering of list items. + +tiletypes +========= + +* ``bool tiletypes_setTile(pos, shape, material, special, variant)`` where + the parameters are enum values from ``df.tiletype_shape``, + ``df.tiletype_material``, etc. Returns whether the conversion succeeded. + +* ``bool tiletypes_setTile(pos, tiletype_options)`` where + the ``tiletype_options`` parameter takes in a table, with any fields matching + the available tiletypes options. Any unspecified fields default to keeping + the value of the original tile. Returns whether the conversion succeeded. + - ``shape``: ``df.tiletype_shape`` + - ``material``: ``df.tiletype_material`` + - ``special``: ``df.tiletype_special`` + - ``variant``: ``df.tiletype_variant`` + - ``hidden``: -1, 0, or 1 + - ``light``: -1, 0, or 1 + - ``subterranean``: -1, 0, or 1 + - ``skyview``: -1, 0, or 1 + - ``aquifer``: -1, 0, 1, or 2 + - ``autocorrect``: 0 or 1 + - ``stone_material``: integer material id + - ``vein_type``: ``df.inclusion_type`` + +.. _xlsxreader-api: + +xlsxreader +========== + +Utility functions to facilitate reading .xlsx spreadsheets. It provides the +following low-level API methods: + +- ``open_xlsx_file(filename)`` returns a file_handle or nil on error +- ``close_xlsx_file(file_handle)`` closes the specified file_handle +- ``list_sheets(file_handle)`` returns a list of strings representing sheet + names +- ``open_sheet(file_handle, sheet_name)`` returns a sheet_handle. This call + always succeeds, even if the sheet doesn't exist. Non-existent sheets will + have no data, though. +- ``close_sheet(sheet_handle)`` closes the specified sheet_handle +- ``get_row(sheet_handle, max_tokens)`` returns a list of strings representing + the contents of the cells in the next row. The ``max_tokens`` parameter is + optional. If set to a number > 0, it limits the number of cells read and + returned for the row. + +The plugin also provides Lua class wrappers for ease of use: + +- ``XlsxioReader`` provides access to .xlsx files +- ``XlsxioSheetReader`` provides access to sheets within .xlsx files +- ``open(filepath)`` initializes and returns an ``XlsxioReader`` object + +The ``XlsxioReader`` class has the following methods: + +- ``XlsxioReader:close()`` closes the file. Be sure to close any open child + sheet handles first! +- ``XlsxioReader:list_sheets()`` returns a list of strings representing sheet + names +- ``XlsxioReader:open_sheet(sheet_name)`` returns an initialized + ``XlsxioSheetReader`` object + +The ``XlsxioSheetReader`` class has the following methods: + +- ``XlsxioSheetReader:close()`` closes the sheet +- ``XlsxioSheetReader:get_row(max_tokens)`` reads the next row from the sheet. + If ``max_tokens`` is specified and is a positive integer, only the first + ``max_tokens`` elements of the row are returned. + +Here is an end-to-end example:: + + local xlsxreader = require('plugins.xlsxreader') + + local function dump_sheet(reader, sheet_name) + print('reading sheet: ' .. sheet_name) + local sheet_reader = reader:open_sheet(sheet_name) + dfhack.with_finalize( + function() sheet_reader:close() end, + function() + local row_cells = sheet_reader:get_row() + while row_cells do + printall(row_cells) + row_cells = sheet_reader:get_row() + end + end + ) + end + + local filepath = 'path/to/some_file.xlsx' + local reader = xlsxreader.open(filepath) + dfhack.with_finalize( + function() reader:close() end, + function() + for _,sheet_name in ipairs(reader:list_sheets()) do + dump_sheet(reader, sheet_name) + end + end + ) + +======= +Scripts +======= + +.. contents:: + :local: + +Any files with the ``.lua`` extension placed into the :file:`hack/scripts` folder +(or any other folder in your `script-paths`) are automatically made available as +DFHack commands. The command corresponding to a script is simply the script's +filename, relative to the scripts folder, with the extension omitted. For example: + +* :file:`dfhack-config/scripts/startup.lua` is invoked as ``startup`` +* :file:`hack/scripts/gui/teleport.lua` is invoked as ``gui/teleport`` + +.. note:: + In general, scripts should be placed in subfolders in the following + situations: + + * ``devel``: scripts that are intended exclusively for DFHack development, + including examples, or scripts that are experimental and unstable + * ``fix``: fixes for specific DF issues + * ``gui``: GUI front-ends for existing tools (for example, see the + relationship between `teleport` and `gui/teleport`) + * ``modtools``: scripts that are intended to be run exclusively as part of + mods, not directly by end-users (as a rule of thumb: if someone other than + a mod developer would want to run a script from the console, it should + not be placed in this folder) + +Scripts are read from disk when run for the first time, or if they have changed +since the last time they were run. + +Each script has an isolated environment where global variables set by the script +are stored. Values of globals persist across script runs in the same DF session. +See `devel/lua-example` for an example of this behavior. Note that ``local`` +variables do *not* persist. + +Arguments are passed in to the scripts via the ``...`` built-in quasi-variable; +when the script is called by the DFHack core, they are all guaranteed to be +non-nil strings. + +Additional data about how a script is invoked is passed to the script as a +special ``dfhack_flags`` global, which is unique to each script. This table +is guaranteed to exist, but individual entries may be present or absent +depending on how the script was invoked. Flags that are present are described +in the subsections below. + +DFHack invokes the scripts in the `core context `; however it +is possible to call them from any lua code (including from other scripts) in any +context with ``dfhack.run_script()`` below. + +General script API +================== + +* ``dfhack.run_script(name[,args...])`` + + Run a Lua script in your `script-paths`, as if it were started from the + DFHack command-line. The ``name`` argument should be the name of the script + without its extension, as it would be used on the command line. + + Example: + + In DFHack prompt:: + + repeat -time 14 -timeUnits days -command [ workorder ShearCreature ] -name autoShearCreature + + In Lua script:: + + dfhack.run_script("repeat", "-time", "14", "-timeUnits", "days", "-command", "[", "workorder", "ShearCreature", "]", "-name", "autoShearCreature") + + Note that the ``dfhack.run_script()`` function allows Lua errors to propagate to the caller. + + To run other types of commands (i.e., built-in commands or commands provided by plugins), + see ``dfhack.run_command()``. Note that this is slightly slower than ``dfhack.run_script()`` + when running Lua scripts. + +* ``dfhack.script_help([name, [extension]])`` + + Returns the contents of the rendered (or embedded) `documentation` for the + specified script. ``extension`` defaults to "lua", and ``name`` defaults to + the name of the script where this function was called. For example, the + following can be used to print the current script's help text:: + + local args = {...} + if args[1] == 'help' then + print(script_help()) + return + end + +.. _reqscript: + +Importing scripts +================= + +* ``dfhack.reqscript(name)`` or ``reqscript(name)`` + + Loads a Lua script and returns its environment (i.e., a table of all global + functions and variables). This is similar to the built-in ``require()``, but + searches all `script-paths` for the first matching ``name.lua`` file instead + of searching the Lua library paths (like ``hack/lua/``). + + Most scripts can be made to support ``reqscript()`` without significant + changes (in contrast, ``require()`` requires the use of ``mkmodule()`` and + some additional boilerplate). However, because scripts can have side effects + when they are loaded (such as printing messages or modifying the game state), + scripts that intend to support being imported must satisfy some criteria to + ensure that they can be imported safely: + + 1. Include the following line - ``reqscript()`` will fail if this line is + not present:: + + --@ module = true + + In order to be recognized, this line **must** begin with ``--@`` with no + whitespace characters before it:: + + --@ module = true OK + --@module = true OK + -- @module = true NOT OK (no --@ found due to space after --) + --@module = true NOT OK (leading space, --@ is not at the beginning of the line) + ---@module = true NOT OK (leading dash, --@ is not at the beginning of the line) + + 2. Include a check for ``dfhack_flags.module``, and avoid running any code + that has side-effects if this flag is true. For instance:: + + -- (function definitions) + if dfhack_flags.module then + return + end + -- (main script code with side-effects) + + or:: + + -- (function definitions) + function main() + -- (main script code with side-effects) + end + if not dfhack_flags.module then + main() + end + + Example usage:: + + local addThought = reqscript('add-thought') + addThought.addEmotionToUnit(unit, ...) + + Circular dependencies between scripts are supported, as long as the scripts + have no side-effects at load time (which should already be the case per + the above criteria). + + .. warning:: + + Avoid caching the table returned by ``reqscript()`` beyond storing it in + a local variable as in the example above. ``reqscript()`` is fast for + scripts that have previously been loaded and haven't changed. If you retain + a reference to a table returned by an old ``reqscript()`` call, this may + lead to unintended behavior if the location of the script changes (e.g., if a + save is loaded or unloaded, or if a `script path ` is added in + some other way). + + .. admonition:: Tip + + Mods that include custom Lua modules can write these modules to support + ``reqscript()`` and distribute them as scripts in ``raw/scripts``. Since the + entire ``raw`` folder is copied into new saves, this will allow saves to be + successfully transferred to other users who do not have the mod installed + (as long as they have DFHack installed). + + .. admonition:: Backwards compatibility notes + + For backwards compatibility, ``moduleMode`` is also defined if + ``dfhack_flags.module`` is defined, and is set to the same value. + Support for this may be removed in a future version. + +* ``dfhack.script_environment(name)`` + + Similar to ``reqscript()`` but does not enforce the check for module support. + This can be used to import scripts that support being used as a module but do + not declare support as described above, although it is preferred to update + such scripts so that ``reqscript()`` can be used instead. + +.. _script-enable-api: + +Enabling and disabling scripts +============================== + +Scripts can choose to recognize the built-in ``enable`` and ``disable`` commands +by including the following line near the top of their file:: + + --@enable = true + --@module = true + +Note that enableable scripts must also be `modules ` so their +``isEnabled()`` functions can be called from outside the script. + +When the ``enable`` and ``disable`` commands are invoked, the ``dfhack_flags`` +table passed to the script will have the following fields set: + +* ``enable``: Always ``true`` if the script is being enabled *or* disabled +* ``enable_state``: ``true`` if the script is being enabled, ``false`` otherwise + +If you declare a global function named ``isEnabled`` that returns a boolean +indicating whether your script is enabled, then your script will be listed among +the other enableable scripts and plugins when the player runs the `enable` +command. + +Example usage:: + + --@enable = true + --@module = true + + enabled = enabled or false + function isEnabled() + return enabled + end + + -- (function definitions...) + + if dfhack_flags.enable then + if dfhack_flags.enable_state then + start() + enabled = true + else + stop() + enabled = false + end + end + +If the state of your script can be tied to an active savegame, then your script +should hook the appropriate events to load persisted state when a savegame is +loaded. For example:: + + local utils = require('utils') + + local GLOBAL_KEY = 'my-script-name' + + local function get_default_state() + return { + -- add default config here, e.g., + -- enabled=false, + } + end + + state = state or get_default_state() + + dfhack.onStateChange[GLOBAL_KEY] = function(sc) + if sc ~= SC_MAP_LOADED or df.global.gamemode ~= df.game_mode.DWARF then + return + end + -- retrieve state saved in game. merge with default state so config + -- saved from previous versions can pick up newer defaults. + state = get_default_state() + utils.assign(state, dfhack.persistent.getSiteData(GLOBAL_KEY, state)) + end + + -- to be called when global state changes that needs to be persisted + local function persist_state() + dfhack.persistent.saveSiteData(GLOBAL_KEY, state) + end + +The attachment to ``dfhack.onStateChange`` should appear in your script code +outside of any function. DFHack will load your script as a module just before +the ``SC_DFHACK_INITIALIZED`` state change event is sent, giving your code an +opportunity to run and attach hooks before the game is loaded. + +If an enableable script is added to a DFHack `script path ` while +DF is running, then it will miss the initial sweep that loads all the module +scripts and any ``onStateChange`` handlers the script may want to register will +not be registered until the script is loaded via some means, either by running +it or loading it as a module. If you just added new scripts that you want to +load so they can attach their ``onStateChange`` handlers, run ``enable`` without +parameters or call ``:lua require('script-manager').reload()`` to scan and load +all script modules. + +Save init script +================ + +If a save directory contains a file called ``init.lua``, it is +automatically loaded and executed every time the save is loaded. +The same applies to any files called ``init.d/*.lua``. Every +such script can define the following functions to be called by dfhack: + +* ``function onStateChange(op) ... end`` + + Automatically called from the regular onStateChange event as long + as the save is still loaded. This avoids the need to install a hook + into the global ``dfhack.onStateChange`` table, with associated + cleanup concerns. + +* ``function onUnload() ... end`` + + Called when the save containing the script is unloaded. This function + should clean up any global hooks installed by the script. Note that + when this is called, the world is already completely unloaded. + +Within the init script, the path to the save directory is available as ``SAVE_PATH``. diff --git a/docs/dev/Memory-research.rst b/docs/dev/Memory-research.rst new file mode 100644 index 0000000000..2ee47bb05b --- /dev/null +++ b/docs/dev/Memory-research.rst @@ -0,0 +1,162 @@ +.. _memory-research: + +############### +Memory research +############### + +There are a variety of tools that can be used to analyze DF memory - some are +listed here. Note that some of these may be old and unmaintained. If you aren't +sure what tool would be best for your purposes, feel free to ask for advice (on +IRC, Bay12, etc.). + +.. contents:: Contents + :local: + + +Cross-platform tools +==================== + +Ghidra +------ + +Ghidra is a cross-platform reverse-engineering framework (written in Java) +available at https://ghidra-sre.org. It supports analyzing both 32-bit and +64-bit executables for all supported DF platforms. There are some custom DFHack +Ghidra scripts available in the `df_misc`_ repo (look for ``.java`` files). + + +IDA Freeware 7.0 +---------------- + +Available from `Hex-Rays `_. +Supports analyzing both 32-bit and 64-bit executables for all supported DF platforms. +Some ``.idc`` scripts for IDA are available in the `df_misc`_ repo. + +.. _df_misc: https://github.com/DFHack/df_misc + + +Hopper +------ + +Runs on macOS and some Linux distributions; available from https://www.hopperapp.com/. +`TWBT `_ uses this to produce some patches. + + +DFHack tools +------------ + +Plugins +~~~~~~~ + +There are a few development plugins useful for low-level memory research. They +are not built by default, but can be built by setting the ``BUILD_DEVEL`` +`CMake option `. These include: + +- ``check-structures-sanity``, which performs sanity checks on the given DF + object. Note that this will crash in several cases, some intentional, so using + this with `GDB ` is recommended. +- ``memview``, which produces a hex dump of a given memory range. It also + highlights valid pointers, and can be configured to work with `sizecheck` + to auto-detect object sizes. +- ``vectors``, which can identify instances of ``std::vector`` in a given memory range. + +Scripts +~~~~~~~ + +Several `development tools ` can be useful for memory research. +These include (but are not limited to): + +- `devel/dump-offsets` +- `devel/find-offsets` +- `devel/lsmem` +- `devel/sc` (requires `sizecheck`) +- `devel/visualize-structure` +- Generally, any script starting with ``devel/find`` + +.. _sizecheck: + +Sizecheck +~~~~~~~~~ + +Sizecheck is a custom tool that hooks into the memory allocator and inserts a +header indicating the size of every object. The corresponding logic to check for +this header when freeing memory usually works, but is inherently not foolproof. +You should not count on DF being stable when using this. + +DFHack's implementation of sizecheck is currently only tested on Linux, although +it probably also works on macOS. It can be built with the ``BUILD_SIZECHECK`` +`CMake option `, which produces a ``libsizecheck`` +library installed in the ``hack`` folder. On Linux, passing ``--sc`` as the +first argument to the ``dfhack`` launcher script will load this library on +startup. On other platforms, or when passing a different argument to the +launcher (such as for `linux-gdb`), you will need to preload this library +manually, by setting ``PRELOAD_LIB`` on Linux (or ``LD_PRELOAD`` if editing the +``dfhack`` launcher script directly), or by editing the ``dfhack`` launcher +script and adding the library to ``DYLD_INSERT_LIBRARIES`` on macOS. + +There is also an older sizecheck implementation by Mifki available on +`GitHub `__ (``b.cpp`` is the main +sizecheck library, and ``win_patch.cpp`` is used for Windows support). To use +this with other DFHack tools, you will likely need to edit the header's +magic number to match what is used in `devel/sc` (search for a hexadecimal +constant starting with ``0x``). + +Legacy tools +~~~~~~~~~~~~ + +Some very old DFHack tools are available in the `legacy branch on GitHub `_. +No attempt is made to support these. + + +Linux-specific tools +==================== + +.. _linux-gdb: + +GDB +--- + +`GDB `_ is technically cross-platform, but +tends to work best on Linux, and DFHack currently only offers support for using +GDB on 64-bit Linux. To start with GDB, pass ``-g`` to the DFHack launcher +script: + +.. code-block:: shell + + ./dfhack -g + +Some basic GDB commands: + +- ``run``: starts DF from the GDB prompt. Any arguments will be passed as + command-line arguments to DF (e.g. `load-save` may be useful). +- ``bt`` will produce a backtrace if DF crashes. + +See the `official GDB documentation `_ +for more details. + +Other analysis tools +-------------------- + +The ``dfhack`` launcher script on Linux has support for launching several other +tools alongside DFHack, including Valgrind (as well as Callgrind and Helgrind) +and strace. See the script for the exact command-line option to specify. Note +that currently only one tool at a time is supported, and must be specified +with the first argument to the script. + +df-structures GUI +----------------- + +This is a tool written by Angavrilov and available on `GitHub `__. +It only supports 32-bit DF. Some assistance may be available on IRC. + + +EDB (Evan's debugger) +--------------------- + +Available on `GitHub `__. + + +Windows-specific tools +====================== + +Some people have used `Cheat Engine `__ for research in the past. diff --git a/docs/dev/Remote.rst b/docs/dev/Remote.rst new file mode 100644 index 0000000000..c98d6ae520 --- /dev/null +++ b/docs/dev/Remote.rst @@ -0,0 +1,236 @@ +.. _remote: + +======================= +DFHack remote interface +======================= + +DFHack provides a remote access interface that external tools can connect to and +use to interact with DF. This is implemented with `Google protobuf`_ messages +exchanged over a TCP socket. Both the core and plugins can define +remotely-accessible methods, or **RPC methods**. The RPC methods currently +available are not comprehensive, but can be extended with plugins. + +.. _Google protobuf: https://developers.google.com/protocol-buffers + +.. contents:: Contents + :local: + + +.. _remote-server-config: + +Server configuration +==================== + +DFHack attempts to start a TCP server to listen for remote connections on +startup. If this fails (due to the port being in use, for example), an error +message will be logged to stderr.log. + +The server can be configured by setting options in ``dfhack-config/remote-server.json``: + +- ``allow_remote`` (default: ``false``): if true, allows connections from hosts + other than the local machine. This is insecure and may allow arbitrary code + execution on your machine, so it is disabled by default. +- ``port`` (default: ``5000``): the port that the remote server listens on. + Overriding this will allow the server to work if you have multiple instances + of DF running, or if you have something else running on port 5000. Note that + the ``DFHACK_PORT`` `environment variable ` takes precedence over + this setting and may be more useful for overriding the port temporarily. + + +Developing with the remote API +============================== + +At a high level, the core and plugins define RPC methods, and external clients +can call these methods. Each method is assigned an ID internally, which clients +use to call it. These method IDs can be obtained using the special ``BindMethod`` +method, which has an ID of 0. + +Examples +-------- + +The `dfhack-run` command uses the RPC interface to invoke DFHack commands +(or Lua functions) externally. + +Plugins that implement RPC methods include: + +- `rename` +- `remotefortressreader` + +Plugins that use the RPC API include: + +- `stonesense` + +Third-party tools that use the RPC API include: + +- `Armok Vision `_ (:forums:`Bay12 forums thread <146473>`) + +.. _remote-client-libs: + +Client libraries +---------------- + +Some external libraries are available for interacting with the remote interface +from other (non-C++) languages, including: + +- `RemoteClientDF-Net `_ for C# +- `dfhackrpc `_ for Go +- `dfhack-remote `__ for JavaScript +- `dfhack-client-qt `_ for C++ with Qt +- `dfhack-client-python `_ for Python (adapted from :forums:`"Blendwarf" <178089>`) +- `dfhack-client-java `_ for Java +- `dfhack-remote `__ for Rust + + +Protocol description +==================== + +This is a low-level description of the RPC protocol, which may be useful when +developing custom clients. + +A WireShark dissector for this protocol is available in the +`df_misc repo `_. + + +Built-in messages +----------------- +These messages have hardcoded IDs; all others must be obtained through ``BindMethod``. + +=== ============ =============================== ======================= +ID Method Input Output +=== ============ =============================== ======================= + 0 BindMethod dfproto.CoreBindRequest dfproto.CoreBindReply + 1 RunCommand dfproto.CoreRunCommandRequest dfproto.EmptyMessage +=== ============ =============================== ======================= + +Conversation flow +----------------- + +* Client → Server: `handshake request`_ +* Server → Client: `handshake reply`_ +* Repeated 0 or more times: + * Client → Server: `request`_ + * Server → Client: `text`_ (0 or more times) + * Server → Client: `result`_ or `failure`_ +* Client → Server: `quit`_ + +Raw message types +----------------- + +* All numbers are little-endian +* All strings are ASCII +* A payload size of greater than 64MiB is an error +* See ``RemoteClient.h`` for definitions of constants starting with ``RPC`` + +handshake request +~~~~~~~~~~~~~~~~~ + +.. csv-table:: + :align: left + :header-rows: 1 + + Type, Name, Value + char[8], magic, ``DFHack?\n`` + int32_t, version, 1 + +handshake reply +~~~~~~~~~~~~~~~ + +.. csv-table:: + :align: left + :header-rows: 1 + + Type, Name, Value + char[8], magic, ``DFHack!\n`` + int32_t, version, 1 + +header +~~~~~~ + +**Note:** the two fields of this message are sometimes repurposed. Uses of this +message are represented as ``header(x, y)``, where ``x`` corresponds to the ``id`` +field and ``y`` corresponds to ``size``. + +.. csv-table:: + :align: left + :header-rows: 1 + + Type, Name + int16_t, id + int16_t, (padding - unused) + int32_t, size + +request +~~~~~~~ + +.. list-table:: + :align: left + :header-rows: 1 + :widths: 25 75 + + * - Type + - Description + * - `header`_ + - ``header(id, size)`` + * - buffer + - Protobuf-encoded payload of the input message type of the method specified by ``id``; length of ``size`` bytes + +text +~~~~ + +.. list-table:: + :align: left + :header-rows: 1 + :widths: 25 75 + + * - Type + - Description + * - `header`_ + - ``header(RPC_REPLY_TEXT, size)`` + * - buffer + - Protobuf-encoded payload of type ``dfproto.CoreTextNotification``; length of ``size`` bytes + +result +~~~~~~ + +.. list-table:: + :align: left + :header-rows: 1 + :widths: 25 75 + + * - Type + - Description + * - `header`_ + - ``header(RPC_REPLY_RESULT, size)`` + * - buffer + - Protobuf-encoded payload of the output message type of the oldest incomplete method call; when received, + that method call is considered completed. Length of ``size`` bytes. + +failure +~~~~~~~ + +.. list-table:: + :align: left + :header-rows: 1 + :widths: 25 75 + + * - Type + - Description + * - `header`_ + - ``header(RPC_REPLY_FAIL, command_result)`` + * - command_result + - return code of the command (a constant starting with ``CR_``; see ``RemoteClient.h``) + +quit +~~~~ + +**Note:** the server closes the connection after receiving this message. + +.. list-table:: + :align: left + :header-rows: 1 + :widths: 25 75 + + * - Type + - Description + * - `header`_ + - ``header(RPC_REQUEST_QUIT, 0)`` diff --git a/docs/dev/Structures-intro.rst b/docs/dev/Structures-intro.rst new file mode 100644 index 0000000000..8fe8d6e99b --- /dev/null +++ b/docs/dev/Structures-intro.rst @@ -0,0 +1,32 @@ +=================================== +DF data definitions (DF-structures) +=================================== + +DFHack's information about DF's data structures is stored in XML files in the +`df-structures repository `_. If you +have `obtained a local copy of the DFHack source `, +DF-structures is included as a submodule in ``library/xml``. + +Data structure layouts are described in files named with the ``df.*.xml`` +pattern. This information is transformed by a Perl script (``codegen.pl``) into +C++ headers, as well as metadata for the Lua wrapper. This ultimately allows +DFHack code to access DF data directly, with the same speed and capabilities as +DF itself, which is an advantage over the older out-of-process approach (used +by debuggers and utilities like Dwarf Therapist). The main disadvantage of this +approach is that any compiled code relying on these layouts will break when DF's +layout changes, and will need to be recompiled for every new DF version. + +Addresses of DF global objects and vtables are stored in a separate file, +:file:`symbols.xml`. Since these are only absolute addresses, they do not need +to be compiled into DFHack code, and are instead loaded at runtime. This makes +fixes and additions to global addresses possible without recompiling DFHack. +In an installed copy of DFHack, this file can be found at the root of the +``hack`` folder. + +Please see the following page for detailed information about the syntax of the +df-structures XML files: + +.. toctree:: + :titlesonly: + + /library/xml/SYNTAX diff --git a/docs/dev/compile/Compile.rst b/docs/dev/compile/Compile.rst new file mode 100644 index 0000000000..2ad2c52efb --- /dev/null +++ b/docs/dev/compile/Compile.rst @@ -0,0 +1,455 @@ +.. highlight:: shell + +.. _compile: + +########### +Compilation +########### + +DFHack builds are available for all supported platforms; see `installing` for +installation instructions. If you are a DFHack end-user, modder, or plan on +writing scripts [lua] (not plugins), it is generally recommended (and easier) to use +these `builds `_ instead of compiling DFHack from source. + +However, if you are looking to develop plugins, work on the DFHack core, make +complex changes to DF-structures, or anything else that requires compiling +DFHack from source, this document will walk you through the build process. Note +that some steps may be unconventional compared to other projects, so be sure to +pay close attention if this is your first time compiling DFHack. + +.. contents:: Contents + :local: + :depth: 2 + +.. _compile-how-to-get-the-code: + +How to get the code +=================== +DFHack uses Git for source control; instructions for installing Git can be found +in the platform-specific sections below. The code is hosted on +`GitHub `_, and can be downloaded with:: + + git clone --recursive https://github.com/DFHack/dfhack + cd dfhack + +If your version of Git does not support the ``--recursive`` flag, you will need +to omit it and run ``git submodule update --init`` after entering the dfhack +directory. + +This will check out the code on the default branch of the GitHub repo, currently +``develop``, which may be unstable. If you want code for the latest stable +release, you can check out the ``master`` branch instead:: + + git checkout master + git submodule update + +In general, a single DFHack clone is suitable for development - most Git +operations such as switching branches can be done on an existing clone. If you +find yourself cloning DFHack frequently as part of your development process, or +getting stuck on anything else Git-related, feel free to reach out to us for +assistance. + +.. admonition:: Offline builds + + If you plan to build DFHack on a machine without an internet connection (or + with an unreliable connection), see `note-offline-builds` for additional + instructions. + +.. admonition:: Working with submodules + + DFHack uses submodules extensively to manage its subprojects (including the + ``scripts`` folder and DF-structures in ``library/xml``). Failing to keep + submodules in sync when switching between branches can result in build errors + or scripts that don't work. In general, you should always update submodules + whenever you switch between branches in the main DFHack repo with + ``git submodule update``. (If you are working on bleeding-edge DFHack and + have checked out the master branch of some submodules, running ``git pull`` + in those submodules is also an option.) + + Rarely, we add or remove submodules. If there are any changes to the existence + of submodules when you switch between branches, you should run + ``git submodule update --init`` instead (adding ``--init`` to the above + command). + + Some common errors that can arise when failing to update submodules include: + + * ``fatal: does not exist`` when performing Git operations + * Build errors, particularly referring to structures in the ``df::`` namespace + or the ``library/include/df`` folder + * ``Not a known DF version`` when starting DF + * ``Run 'git submodule update --init'`` when running CMake + + Submodules are a particularly confusing feature of Git. The + `Git Book `_ has a + thorough explanation of them (as well as of many other aspects of Git) and + is a recommended resource if you run into any issues. Other DFHack developers + are also able to help with any submodule-related (or Git-related) issues + you may encounter. + +All Platforms +============= +Before you can compile the code you'll need to configure your build with cmake. Some IDEs can do this +for you, but it's more common to do it from the command line. Windows developers can refer to the +Windows section below for batch files that can be used to avoid opening a terminal/command-prompt. + +You should seek cmake's documentation online or via ``cmake --help`` to see how the command works. See +the `build-options` page for help finding the DFHack build options relevant to you. + +Before compiling code, you'll of course need code to compile. This **will include** the submodules, so +be sure you've read the section about getting the code. + +.. _compile-linux: + +Linux +===== + +Building is fairly straightforward. Enter the ``build`` folder (or create an +empty folder in the DFHack directory to use instead) and start the build like this:: + + cd build + cmake .. -G Ninja -DCMAKE_BUILD_TYPE:string=Release -DCMAKE_INSTALL_PREFIX= + ninja install # or ninja -jX install to specify the number of cores (X) to use + + should be a path to a copy of Dwarf Fortress, of the appropriate +version for the DFHack you are building. This will build the library along +with the normal set of plugins and install them into your DF folder. + +Alternatively, you can use ccmake instead of cmake:: + + cd build + ccmake .. -G Ninja + ninja install + +This will show a curses-based interface that lets you set all of the +extra options. You can also use a cmake-friendly IDE like KDevelop 4 +or the cmake-gui program. + +.. _compile-windows: + +Windows +======= +There are several different batch files in the ``win32`` and ``win64`` +subfolders in the ``build`` folder, along with a script that's used for picking +the DF path. Use the subfolder corresponding to the architecture that you want +to build for. + +First, run ``set_df_path.vbs`` and point the dialog that pops up at +a suitable DF installation which is of the appropriate version for the DFHack +you are compiling. The result is the creation of the file ``DF_PATH.txt`` in +the build directory. It contains the full path to the destination directory. +You could therefore also create this file manually - or copy in a pre-prepared +version - if you prefer. + +Next, run one of the scripts with ``generate`` prefix. These create the MSVC +solution file(s): + +* ``all`` will create a solution with everything enabled (and the kitchen sink). +* ``gui`` will pop up the CMake GUI and let you choose what to build. + This is probably what you want most of the time. Set the options you are interested + in, then hit configure, then generate. More options can appear after the configure step. +* ``minimal`` will create a minimal solution with just the bare necessities - + the main library and standard plugins. +* ``release`` will create a solution with everything that should be included in + release builds of DFHack. Note that this includes documentation, which requires + Python. + +Then you can either open the solution with MSVC or use one of the msbuild scripts. + +Visual Studio IDE +----------------- +After running the CMake generate script you will have a new folder called VC2022 +or VC2022_32, depending on the architecture you specified. Open the file +``dfhack.sln`` inside that folder. If you have multiple versions of Visual +Studio installed, make sure you open with Visual Studio 2022. + +The first thing you must then do is ensure the build type is not Debug, which +cannot be used on Windows. Debug is not binary-compatible with DF. +If you try to use a debug build with DF, you'll only get crashes and for this +reason the Windows "debug" scripts actually do RelWithDebInfo builds. +After loading the Solution, change the Build Type to either ``Release`` +or ``RelWithDebInfo``. + +Then build the ``INSTALL`` target listed under ``CMakePredefinedTargets``. + +Command Line +------------ +In the build directory you will find several ``.bat`` files: + +* Scripts with ``build`` prefix will only build DFHack. +* Scripts with ``install`` prefix will build DFHack and install it to the previously selected DF path. +* Scripts with ``package`` prefix will build and create a .zip package of DFHack. + +Compiling from the command line is generally the quickest and easiest option. +Modern Windows terminal emulators such as `Cmder `_ or +`Windows Terminal `_ provide a better +experience by providing more scrollback and larger window sizes. + +.. _compile-macos: + +macOS +===== + +NOTE: this section is currently outdated. Once DF itself can build on macOS +again, we will match DF's build environment and update the instructions here. + +DFHack functions similarly on macOS and Linux, and the majority of the +information above regarding the build process (CMake and Ninja) applies here +as well. + +DFHack can officially be built on macOS only with GCC 4.8 or 7. Anything newer than 7 +will require you to perform extra steps to get DFHack to run (see `osx-new-gcc-notes`), +and your build will likely not be redistributable. + +Building +-------- + +* Get the DFHack source as per section `compile-how-to-get-the-code`, above. +* Set environment variables + + Homebrew (if installed elsewhere, replace /usr/local with ``$(brew --prefix)``):: + + export CC=/usr/local/bin/gcc-7 + export CXX=/usr/local/bin/g++-7 + + Macports:: + + export CC=/opt/local/bin/gcc-mp-7 + export CXX=/opt/local/bin/g++-mp-7 + + Change the version numbers appropriately if you installed a different version of GCC. + + If you are confident that you have GCC in your path, you can omit the absolute paths:: + + export CC=gcc-7 + export CXX=g++-7 + + (adjust as needed for different GCC installations) + +* Build DFHack:: + + mkdir build-osx + cd build-osx + cmake .. -G Ninja -DCMAKE_BUILD_TYPE:string=Release -DCMAKE_INSTALL_PREFIX= + ninja install # or ninja -jX install to specify the number of cores (X) to use + + should be a path to a copy of Dwarf Fortress, of the appropriate + version for the DFHack you are building. + +.. _osx-new-gcc-notes: + +Notes for GCC 8+ or OS X 10.10+ users +------------------------------------- + +If you have issues building on OS X 10.10 (Yosemite) or above, try defining +the following environment variable:: + + export MACOSX_DEPLOYMENT_TARGET=10.9 + +If you build with a GCC version newer than 7, DFHack will probably crash +immediately on startup, or soon after. To fix this, you will need to replace +``hack/libstdc++.6.dylib`` with a symlink to the ``libstdc++.6.dylib`` included +in your version of GCC:: + + cd /hack && mv libstdc++.6.dylib libstdc++.6.dylib.orig && + ln -s [PATH_TO_LIBSTDC++] . + +For example, with GCC 6.3.0, ``PATH_TO_LIBSTDC++`` would be:: + + /usr/local/Cellar/gcc@6/6.3.0/lib/gcc/6/libstdc++.6.dylib # for 64-bit DFHack + /usr/local/Cellar/gcc@6/6.3.0/lib/gcc/6/i386/libstdc++.6.dylib # for 32-bit DFHack + +**Note:** If you build with a version of GCC that requires this, your DFHack +build will *not* be redistributable. (Even if you copy the ``libstdc++.6.dylib`` +from your GCC version and distribute that too, it will fail on older OS X +versions.) For this reason, if you plan on distributing DFHack, it is highly +recommended to use GCC 4.8 or 7. + +.. _osx-m1-notes: + +Notes for M1 users +------------------ + +Alongside the above, you will need to follow these additional steps to get it +running on Apple silicon. + +Install an x86 copy of ``homebrew`` alongside your existing one. `This +stackoverflow answer `__ describes the +process. + +Follow the normal macOS steps to install ``cmake`` and ``gcc`` via your x86 copy of +``homebrew``. Note that this will install a GCC version newer than 7, so see +`osx-new-gcc-notes`. + +In your terminal, ensure you have your path set to the correct homebrew in +addition to the normal ``CC`` and ``CXX`` flags above:: + + export PATH=/usr/local/bin:$PATH + +Windows cross compiling from Linux (running DF inside docker) +============================================================= + +.. highlight:: bash + +You can use docker to build DFHack for Windows. These instructions were developed +on a Linux host system. + +.. contents:: + :local: + :depth: 1 + +Step 1: prepare a build container +--------------------------------- + +On your Linux host, install and run the docker daemon and then run these commands:: + + xhost +local:root + docker run -it --env="DISPLAY" --env="QT_X11_NO_MITSHM=1" --volume=/tmp/.X11-unix:/tmp/.X11-unix --user buildmaster --name dfhack-win ghcr.io/dfhack/build-env:master + +The ``xhost`` command and ``--env`` parameters are there so you can eventually +run Dwarf Fortress from the container and have it display on your host. + +Step 2: build DFHack +-------------------- + +The ``docker run`` command above will give you a shell prompt (as the ``buildmaster`` user) in the +container. Inside the container, run the following commands:: + + git clone https://github.com/DFHack/dfhack.git + cd dfhack + git submodule update --init + cd build + dfhack-configure windows 64 Release + dfhack-make + +Inside the ``dfhack-*`` scripts there are several commands that set up the wine +server. Each invocation of a Windows tool will cause wine to run in the container. +Preloading the wineserver and telling it not to exit will speed configuration and +compilation up considerably (approx. 10x). You can configure and build DFHack +with regular ``cmake`` and ``ninja`` commands, but your build will go much slower. + +Step 3: copy Dwarf Fortress to the container +-------------------------------------------- + +First, create a directory in the container to house the Dwarf Fortress binary and +assets:: + + mkdir ~/df + +If you can just download Dwarf Fortress directly into the container, then that's fine. +Otherwise, you can do something like this in your host Linux environment to copy an +installed version to the container:: + + cd ~/.steam/steam/steamapps/common/Dwarf\ Fortress/ + docker cp . dfhack-win:df/ + +Step 4: install DFHack and run DF +--------------------------------- + +Back in the container, run the following commands:: + + cd dfhack/build + cmake .. -DCMAKE_INSTALL_PREFIX=/home/buildmaster/df + ninja install + cd ~/df + wine64 "Dwarf Fortress.exe" + +Other notes +----------- + +Closing your shell will kick you out of the container. Run this command on your Linux +host when you want to reattach:: + + docker start -ai dfhack-win + +If you edit code and need to rebuild, run ``dfhack-make`` and then ``ninja install``. +That will handle all the wineserver management for you. + +Cross-compiling windows files for running DF in Steam for Linux +=============================================================== + +.. highlight:: bash + +If you wish, you can use Docker to build just the Windows files to copy to your +existing Steam installation on Linux. + +.. contents:: + :local: + :depth: 1 + +Step 1: Get dfhack, and run the build script +-------------------------------------------- + +Check out ``dfhack`` into another directory, and run the build script:: + + git clone https://github.com/DFHack/dfhack.git + cd dfhack + git submodule update --init --recursive + cd build + ./build-win64-from-linux.sh + +The script will mount your host's ``dfhack`` directory to docker, use it to +build the artifacts in ``build/win64-cross``, and put all the files needed to +install in ``build/win64-cross/output``. + +If you need to run ``docker`` using ``sudo``, run the script using ``sudo`` +rather than directly:: + + sudo ./build-win64-from-linux.sh + +Step 2: install dfhack to your Steam DF install +----------------------------------------------- +As the script will tell you, you can then copy the files into your DF folder:: + + # Optional -- remove the old hack directory in case we leave files behind + rm ~/.local/share/Steam/steamapps/common/"Dwarf Fortress"/hack + cp -r win64-cross/output/* ~/.local/share/Steam/steamapps/common/"Dwarf Fortress"/ + +Afterward, just run DF as normal. + +.. _note-offline-builds: + +Building DFHack Offline +======================= +As of 0.43.05, DFHack downloads several files during the build process, depending +on your target OS and architecture. If your build machine's internet connection +is unreliable, or nonexistent, you can download these files in advance. + +First, you must locate the files you will need. These can be found in the +`dfhack-bin repo `_. Look for the +most recent version number *before or equal to* the DF version which you are +building for. For example, suppose "0.43.05" and "0.43.07" are listed. You should +choose "0.43.05" if you are building for 0.43.05 or 0.43.06, and "0.43.07" if +you are building for 0.43.07 or 0.43.08. + +Then, download all of the files you need, and save them to ``/CMake/downloads/``. The destination filename you choose +does not matter, as long as the files end up in the ``CMake/downloads`` folder. +You need to download all of the files for the architecture(s) you are building +for. For example, if you are building for 32-bit Linux and 64-bit Windows, +download all files starting with ``linux32`` and ``win64``. GitHub should sort +files alphabetically, so all the files you need should be next to each other. + +.. note:: + + * Any files containing "allegro" in their filename are only necessary for + building `stonesense`. If you are not building Stonesense, you don't have to + download these, as they are larger than any other listed files. + +It is recommended that you create a build folder and run CMake to verify that +you have downloaded everything at this point, assuming your download machine has +CMake installed. This involves running a "generate" batch script on Windows, or +a command starting with ``cmake .. -G Ninja`` on Linux and macOS, following the +instructions in the sections above. CMake should automatically locate files that +you placed in ``CMake/downloads``, and use them instead of attempting to +download them. + +In addition, some packages used by DFHack are managed using CMake's ``FetchContent`` +feature, which requires an online connection during builds. The simplest way to address +this is to have a connection during the first build (during which CMake will download the +dependencies), and then to use CMake's ``FETCHCONTENT_FULLY_DISCONNECTED`` or +``FETCHCONTENT_UPDATES_DISCONNECTED`` defines to control how CMake manages cached +dependencies. If you need even the first-time build be an offline build, you will need +to provide a CMake dependency provider. We do not provide one, but CMake's own documentation +includes a simple provider. For more information about CMake's ``FetchContent`` feature +and how to use it in offline builds, see the +`CMake documentation `_. diff --git a/docs/dev/compile/Dependencies.rst b/docs/dev/compile/Dependencies.rst new file mode 100644 index 0000000000..b42a833785 --- /dev/null +++ b/docs/dev/compile/Dependencies.rst @@ -0,0 +1,303 @@ +.. _build-dependencies: + +############ +Dependencies +############ + +DFHack is meant to be installed into an **existing DF folder**, so ensure that +one is ready. + +.. contents:: Contents + :local: + :depth: 2 + +Overview of Dependencies +======================== + +This section provides an overview of system dependencies that DFHack relies on. +See the platform-specific sections later in this document for specifics on how +to install these dependencies. + +DFHack also has several dependencies on libraries that are included in the +repository as Git submodules, which require no further action to install. + +System dependencies +------------------- + + +* CMake (v3.21 or newer is recommended) +* build system (e.g. gcc & ninja, or Visual Studio) +* Perl 5 (for code generation) + * XML::LibXML + * XML::LibXSLT +* Python 3 (for `documentation `) + * Sphinx +* Git (required for `contributions `_) +* ccache (**optional**, but strongly recommended to improve build times) +* OpenGL headers (**optional**: to build `stonesense`) +* zlib (compression library used for `xlsxreader-api` -> `quickfort`) + +Perl packages +------------- + +* XML::LibXML +* XML::LibXSLT + +The Perl packages are used in code generation. DF memory structures are +represented as XML in DFHack's source tree. During the configuration process +(cmake) the xml files are converted into C++ headers and Lua wrappers for use +by plugins and scripts. + +Python packages +--------------- + +* Sphinx (required to build the `documentation `) + +Installing Dependencies +======================= + +.. contents:: + :local: + :depth: 2 + +.. _linux-dependency-instructions: + +Linux +----- + +Here are some package install commands for various distributions: + +* On Arch Linux:: + + pacman -Sy gcc cmake ccache ninja git dwarffortress zlib perl-xml-libxml perl-xml-libxslt + + * The ``dwarffortress`` package provides the necessary SDL packages. + * For the required Perl modules: ``perl-xml-libxml`` and ``perl-xml-libxslt`` (or through ``cpan``) + +* On Ubuntu:: + + apt-get install gcc cmake ccache ninja-build git zlib1g-dev libsdl2-dev libxml-libxml-perl libxml-libxslt-perl + + * Other Debian-based distributions should have similar requirements. + +* On Fedora:: + + yum install gcc-c++ cmake ccache ninja-build git zlib-devel SDL2-devel perl-core perl-XML-LibXML perl-XML-LibXSLT ruby + +To build DFHack, you need GCC 10 or newer. Note that extremely new GCC versions +may not have been used to build DFHack yet, so if you run into issues with +these, please let us know (e.g. by opening a GitHub issue). + +Distributing binaries compiled with newer GCC versions may result in +compatibility issues for players with older GCC versions. This is why DFHack +builds distributables with GCC 10, which is the same GCC version that DF itself +is compiled with. + +Before you can build anything, you'll also need ``cmake``. It is advisable to +also get ``ccmake`` (the interactive configuration interface) on distributions +that split the cmake package into multiple parts. As mentioned above, ``ninja`` +is recommended as the build system (many distributions call this package +``ninja-build``), but ``make`` also works. + +You will need pthread; most systems should have this already. Note that older +CMake versions may have trouble detecting pthread, so if you run into +pthread-related errors and pthread is installed, you may need to upgrade CMake, +either by downloading it from `cmake.org `_ or +through your package manager, if possible. + +.. _windows-dependency-instructions: + +Windows +------- + +DFHack must be built with the Microsoft Visual C++ 2022 toolchain (aka MSVC v143) +for ABI compatibility with Dwarf Fortress v50. + +.. contents:: + :local: + :depth: 1 + +With Chocolatey +~~~~~~~~~~~~~~~ +Many of the dependencies are simple enough to download and install via the +`chocolatey`_ package manager on the command line. + +Here are some package install commands:: + + choco install cmake + choco install ccache + choco install strawberryperl + choco install python + choco install sphinx + + # Visual Studio + choco install visualstudio2022community --params "--add Microsoft.VisualStudio.Workload.NativeDesktop --includeRecommended" + # OR + # Build Tools for Visual Studio + choco install visualstudio2022buildtools --params "--add Microsoft.VisualStudio.Workload.NativeDesktop --includeRecommended" + +If you already have Visual Studio 2022 or the Build Tools installed, you may +need to modify the installed version to include the workload components +listed in the manual installation section, as chocolatey will not amend +the existing install. + +.. _chocolatey: https://chocolatey.org/install + +Manually +~~~~~~~~ +If you prefer to install manually rather than using Chocolatey, details and +requirements are as below. If you do install manually, **ensure that your PATH +variable is updated** to include the install locations for all tools. This can +be edited from ``Control Panel -> System -> Advanced System Settings -> +Environment Variables``. + +.. contents:: + :local: + :depth: 1 + +CMake +^^^^^ +You can get the Windows installer from `the official site `_. +It has the usual installer wizard. Make sure you let it add its binary folder +to your binary search PATH so the tool can be later run from anywhere. + +Perl / Strawberry Perl +^^^^^^^^^^^^^^^^^^^^^^ +For the code generation stage of the build process, you'll need Perl 5 with the +``XML::LibXML`` and ``XML::LibXSLT`` packages installed. +`Strawberry Perl `_ is recommended as it includes all +of the required packages in a single easy install. + +After install, ensure Perl is in your user's PATH. The following directories must be in your PATH, in this order: + +* ``\c\bin`` +* ``\perl\site\bin`` +* ``\perl\bin`` +* ``\perl\vendor\lib\auto\XML\LibXML`` (path may only be required on some systems) + +Be sure to close and re-open any existing ``cmd.exe`` windows after updating +your PATH. + +If you already have a different version of Perl installed (for example, from Cygwin), +you can run into some trouble. Either remove the other Perl install from PATH, or +install XML::LibXML and XML::LibXSLT for it using CPAN. + +Python +^^^^^^ +See the `Python`_ website. Any supported version of Python 3 will work. + +.. _Python: https://www.python.org/downloads/ + +Sphinx +^^^^^^ +See the `Sphinx`_ website. + +.. _Sphinx: https://www.sphinx-doc.org/en/master/usage/installation.html + +.. _install-visual-studio: + +Visual Studio +^^^^^^^^^^^^^ +The required toolchain can be installed as a part of either the `Visual Studio 2022 IDE`_ +or the `Build Tools for Visual Studio 2022`_. If you already have a preferred code +editor, the Build Tools will be a smaller install. You may need to log into (or create) +a Microsoft account in order to download Visual Studio. + +.. _Visual Studio 2022 IDE: https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&channel=Release&version=VS2022&source=VSLandingPage&cid=2030&passive=false +.. _Build Tools for Visual Studio 2022: https://my.visualstudio.com/Downloads?q=Build%20Tools%20for%20Visual%20Studio%202022 + + +Build Tools [Without Visual Studio] +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Click `Build Tools for Visual Studio 2022`_ and you will be prompted to login to your Microsoft account. +Then you should be redirected to a page with various download options with 2022 +in their name. If this redirect doesn't occur, just copy, paste, and enter the +download link again and you should see the options. + +You want to select the most up-to-date version -- as of writing this is +"Build Tools for Visual Studio 2022 (version 17.4)". "LTSC" is an extended +support variant and is not required for our purposes. + +When installing, select the "Desktop Development with C++" workload and ensure that the following are checked: + +- MSVC v143 - VS 2022 C++ x64/x86 build tools +- C++ CMake tools for Windows +- At least one Windows SDK (for example, Windows 11 SDK 10.0.22621). + +.. _mac-dependency-instructions: + +macOS +----- + +NOTE: this section is currently outdated. Once DF itself can build on macOS +again, we will match DF's build environment and update the instructions here. + +DFHack is easiest to build on macOS with exactly GCC 4.8 or 7. Anything newer than 7 +will require you to perform extra steps to get DFHack to run (see `osx-new-gcc-notes`), +and your build will likely not be redistributable. + +#. Download and unpack a copy of the latest DF +#. Install Xcode from the Mac App Store + +#. Install the XCode Command Line Tools by running the following command:: + + xcode-select --install + +#. Install dependencies + + It is recommended to use Homebrew instead of MacPorts, as it is generally + cleaner, quicker, and smarter. For example, installing MacPort's GCC will + install more than twice as many dependencies as Homebrew's will, and all in + both 32-bit and 64-bit variants. Homebrew also doesn't require constant use + of ``sudo``. + + Using `Homebrew `_ (recommended):: + + brew tap homebrew/versions + brew install git + brew install cmake + brew install ninja + brew install gcc@7 + + Using `MacPorts `_:: + + sudo port install gcc7 +universal cmake +universal git-core +universal ninja +universal + + Macports will take some time - maybe hours. At some point it may ask + you to install a Java environment; let it do so. + +#. Install Perl dependencies + + * Using system Perl + + * ``sudo cpan`` + + If this is the first time you've run cpan, you will need to go through the setup + process. Just stick with the defaults for everything and you'll be fine. + + If you are running OS X 10.6 (Snow Leopard) or earlier, good luck! + You'll need to open a separate Terminal window and run:: + + sudo ln -s /usr/include/libxml2/libxml /usr/include/libxml + + * ``install XML::LibXML`` + * ``install XML::LibXSLT`` + + * In a separate, local Perl install + + Rather than using system Perl, you might also want to consider + the Perl manager, `Perlbrew `_. + + This manages Perl 5 locally under ``~/perl5/``, providing an easy + way to install Perl and run CPAN against it without ``sudo``. + It can maintain multiple Perl installs and being local has the + benefit of easy migration and insulation from OS issues and upgrades. + + See https://perlbrew.pl/ for more details. + +#. Install Python dependencies + + * You can choose to use a system Python 3 installation or any supported + version of Python 3 from `python.org `__. + + * Install `Sphinx`_ diff --git a/docs/dev/compile/Options.rst b/docs/dev/compile/Options.rst new file mode 100644 index 0000000000..462fd1f1ca --- /dev/null +++ b/docs/dev/compile/Options.rst @@ -0,0 +1,163 @@ +.. _build-options: + +############# +Build Options +############# + +.. contents:: Typical Options + :local: + :depth: 1 + +There are a variety of other settings which you can find in CMakeCache.txt in +your build folder or by running ``ccmake`` (or another CMake GUI). Most +DFHack-specific settings begin with ``BUILD_`` and control which parts of DFHack +are built. + +Typical usage may look like:: + + # Plugin development with updated documentation + cmake ./ -G Ninja -B builds/debug-info/ -DCMAKE_INSTALL_PREFIX= -DCMAKE_BUILD_TYPE:string=RelWithDebInfo -DBUILD_DOCS:bool=ON -DBUILD_PLUGINS=1 + # Core DFHack only + cmake ../ -G Ninja -DCMAKE_INSTALL_PREFIX= -DCMAKE_BUILD_TYPE:string=RelWithDebInfo -DBUILD_TESTS -DBUILD_DOCS:0 -DBUILD_PLUGINS=0 + +.. admonition:: Modifying Build Options + + You can typically run new cmake commands from your build directory to turn on/off options. + Of course the generator selection is not something you can change, but the rest are. + + Additionally, you can edit the build settings in CMakeCache.txt. You also have cmake's + configuration utility ``ccmake``. + +Generator +========= +For the uninitiated, the generator is what allows cmake to, of course, generate +visual studio solution & project files, a makefile, or anything else. +Your selection of generator comes down to preference and availability. + +Visual Studio +------------- +To generate visual studio project files, you'll need to select a particular version of +visual studio, and match that to your system's generator list viewed with ``cmake --help`` + +example:: + + cmake .. -G "Visual Studio 17 2022" + +Ninja +----- +The generally preferred build system where available. + +example:: + + cmake .. -G Ninja + +Install Location +================ +This is the location where DFHack will be installed. + +Variable: ``CMAKE_INSTALL_PREFIX`` + +Usage:: + + cmake .. -DCMAKE_INSTALL_PREFIX= + +The path to df will of course depend on your system. If the directory exists it is +recommended to use ``~/.dwarffortress`` to avoid permission troubles. + +Build type +========== +This is the type of build you want. This controls what information about symbols and +line numbers the debugger will have available to it. + +Variable: ``CMAKE_BUILD_TYPE`` + +Usage:: + + cmake .. -DCMAKE_BUILD_TYPE:string=RelWithDebInfo + +Options: + +* Release +* RelWithDebInfo + +Target architecture (32/64-bit) +=============================== +You can set this if you need 32-bit binaries or are looking to be explicit about +building 64-bit. + +Variable: ``DFHACK_BUILD_ARCH`` + +Usage:: + + cmake .. -DDFHACK_BUILD_ARCH=32 + +Options: + +* '32' +* '64' (default option) + +Library +======= +This will only be useful if you're looking to avoid building the library core, as it builds by default. + +Variable: ``BUILD_LIBRARY`` + +Usage:: + + cmake .. -DBUILD_LIBRARY:bool=OFF + cmake .. -DBUILD_LIBRARY=0 + +Testing +======= +Regression testing will be arriving in the future, but for now there are only tests written in lua. + +Variables: + +* ``BUILD_TESTING`` (will build unit tests, in the future) +* ``BUILD_TESTS`` (installs lua tests) + +Usage:: + + cmake .. -DBUILD_TESTS:bool=ON + cmake .. -DBUILD_TESTS=1 + +Plugins +======= +If you're doing plugin development. + +Variable: ``BUILD_PLUGINS`` + +Usage:: + + cmake .. -DBUILD_PLUGINS:bool=ON + cmake .. -DBUILD_PLUGINS=1 + +.. _building-documentation: + +Documentation +============= +If you need to build `documentation `. + +.. note:: + + These options are primarily useful for verifying that the end-to-end process + for building and packaging the documentation is working as expected. For + iterating on documentation changes, `faster alternatives ` are + available. + +Variables: + +* ``BUILD_DOCS``: enables the default documentation build +* ``BUILD_DOCS_NO_HTML``: disables the HTML documentation build (only builds the text documentation used in-game) + +Usage:: + + cmake .. -DBUILD_DOCS:bool=ON + cmake .. -DBUILD_DOCS=1 + cmake .. -DBUILD_DOCS_NO_HTML:bool=ON + cmake .. -DBUILD_DOCS_NO_HTML=1 + +The generated documentation is stored in ``docs/html`` and ``docs/text`` (respectively) +in the root DFHack folder, and they will both be installed to ``hack/docs`` when you +install DFHack. The html and txt files will intermingle, but will not interfere with +one another. diff --git a/docs/dev/compile/index.rst b/docs/dev/compile/index.rst new file mode 100644 index 0000000000..f9f6105ff6 --- /dev/null +++ b/docs/dev/compile/index.rst @@ -0,0 +1,15 @@ +.. _building-dfhack-index: + +=============== +Building DFHack +=============== + +Those seeking to compile the source code for DFHack, including core and plugins, +can refer to the following help pages. + +.. toctree:: + :maxdepth: 2 + + /docs/dev/compile/Dependencies + /docs/dev/compile/Compile + /docs/dev/compile/Options diff --git a/docs/dev/data-identity.rst b/docs/dev/data-identity.rst new file mode 100644 index 0000000000..ae7076941d --- /dev/null +++ b/docs/dev/data-identity.rst @@ -0,0 +1,246 @@ +.. _data_identity: + +########################### +DFHack Data Identity System +########################### + +This article is an attempt to describe DFHack's data identity system. +DFHack internally has a collection of C++ classes that provide metadata about the data in DF itself as well as data used +by various components of DFHack. This metadata is used primarily to enable the Lua scripting system to access data +held by Dwarf Fortress in a transparent manner, but is also used for several other purposes within DFHack, such as rerouting virtual method calls. + +The base class of the identity system is the class ``type_identity``, defined in :source:`DataDefs.h `. A ``type_identity`` object +provides information about one *type* of data object, in either Dwarf Fortress or DFHack, that can be manipulated as a discrete entity in Lua. +With one specific exception (``global_identity``, covered below), there is a one-to-one relationship between C++ types and ``type_identity`` objects. +In Lua, objects that are being managed via the data identity system are represented as a Lua userdata object. The userdata object +contains both a pointer to the C++ object itself and a pointer to a ``type_identity`` object that describes the data pointed +by that pointer. Note that the userdata object does not own the objects pointed to by these pointers, and the Lua engine is +never responsible for managing their lifetimes. + +``type_identity`` defines the following public methods: + +- ``byte_size``: returns the size, in bytes, of the object held + +- ``type``: returns an enum (of type ``identity_type``) classifying the object held. + +- ``getFullName``: returns a string that describes the type. This will usually be similar to a C++ ``typedef``, although this is not guaranteed. + +- ``lua_read``: Used by the Lua engine to "read" the data from a C++ object into the Lua state. + +- ``lua_write``: Used by the Lua engine to "write" a value from the Lua state into a C++ data object. + +- ``build_metatable``: Create a Lua metatable in the specified Lua state corresponding to this type identity. + +- ``is_primitive``: indicates that ``lua_read`` will store a *copy* of the object on the Lua stack instead of a non-owning reference to it. Used for types that have direct representations in Lua: numbers, booleans, simple strings + +- ``is_constructed``: indicates that creating a C++ instance of this type requires the use of a possibly nontrivial constructor. A type identity that is both primitive and constructed cannot be inserted into a container. At the moment the only type identity that is both primitive and constructed is ``stl_string_identity``, which wraps the C++ ``std::string`` type. + +- ``is_container``: indicates that the type is a container and thus implements the methods specific to ``container_identity`` + +- ``allocate``: allocate, and construct if necessary, a C++ instance of this type. This may fail if the type does not support construction. + +- ``copy``: copy the object at ``src`` onto ``tgt``. This uses ``memmove`` for primitive types, and C++ copy-assignment (when possible) for other types + +There are plethora of subclasses of ``type_identity``: + +* ``type_identity`` the abstract base class of all type identities + + * ``constructed_identity`` anything with an internal structure (not primitive) + + * ``compound_identity`` anything with fields + + * ``bitfield_identity`` a structure defined with fields at bit rather than byte boundaries + + * ``enum_identity`` C++ ``enum`` + + * ``struct_identity`` C++ ``class`` or ``structure`` + + * ``global_identity`` holds, as a quasiobject, handles for all of the known Dwarf Fortress program-scope static objects as if they were fields of an object called ``global`` + + * ``union_identity`` C++ ``union`` + + * ``other_vectors_identity`` special-case identity for the categorized subvectors of objects that appears in many of Dwarf Fortress's "handler" classes + + * ``virtual_identity`` polymorphic C++ ``class`` or ``structure`` having a virtual table to handle virtual dispatch + + * ``stl_string_identity`` ``std::string`` + + * ``xlsx_file_handle_identity`` special case + + * ``xlsx_sheet_handle_identity`` special case + + * ``container_identity`` "containers" generally. note that all container types are homogeneous (that is, the elements of the container must all be of the same type). abstract base class + + * ``bit_container_identity`` for containers that contain bools stored one element per *bit* (rather than per byte) + + * ``bit_array_identity`` Dwarf Fortress's ``BitArray`` type + + * ``stl_bit_vector_identity`` ``std::vector`` + + * ``buffer_container_identity`` C++ static arrays and raw C++ pointers acting as arrays of unspecified bound + + * ``enum_list_attr_identity`` (template) metaobject with metadata about a C++ enumeration; may also include additional metadata + + * ``ptr_container_identity`` containers that contain pointers + + * ``stl_ptr_container_identity`` containers that are of the form ``std::vector`` for some ``T`` + + * ``ro_stl_container_identity`` (template) "read only containers" + + * ``ro_stl_assoc_container_identity`` (template) ``std::map`` and ``std::unordered_map`` + + * ``stl_container_identity`` (template) ``std::vector`` where ``T`` is *not* a pointer (and not ``bool``) + + * ``opaque_identity`` opaque wrapper around any type, provides no functionality + + * ``stl_string_identity`` ``std::string`` + + * ``function_identity_base`` abstract base class for ``function_identity`` + + * ``function_identity`` (template) wrapper around a C++ function that can be invoked from Lua + + * ``primitive_identity`` wrapper around a primitive type. primitive types are fixed-length objects with no internal structure + + * ``bool_identity`` ``bool`` + + * ``number_identity_base`` abstract base for numeric types + + * ``float_identity_base`` abstract base for floating point types + + * ``float_identity`` (template) ``double`` and ``float`` + + * ``integer_identity_base`` abstract base for integral types + + * ``integer_identity`` (template) ``int8_t``, ``int16_t``, ``int32_t``, ``size_t``, etc. lots of these + + * ``pointer_identity`` any arbitrary C++ pointer (other than ``char*``) + + * ``ptr_string_identity`` C-style (``char *``) string + +Types marked with "(template)" are C++ template types, all parameterized by a single typename. + +Type identity object lifetime and mutability +============================================ + +*Most* instances of ``type_identity`` are statically constructed and immutable and are thus ``const static`` when constructed. +All ``type_identity`` pointers should be declared ``const``. Due to ``virtual_identity``'s role in implementing +DFHack's vmethod interpose system, it is important that there be at most one ``virtual_identity`` object per virtual class. +Having more than one ``struct_identity`` object for the same type might also potentially lead to misoperation. + +In general, there should be a one to one correspondence between ``type_identity`` objects and C++ types +(with the special case that ``global_identity`` has no corresponding type). As far as we know, for any type other than ``virtual_identity``, +violations of this constraint will not lead to misoperation, but this constraint should not be lightly violated. +The Lua/C++ interface does, in a handful of places, assume that it can compare ``type_identity`` +pointers to determine if they reference the same type, but as far as we know all of these instances will fall +back to correct behavior as long as the shadow copies are indistinguishable from one another; +that is, two copies having the same values will compare equal in all known such comparisons. +Therefore, if two ``type_identity`` objects do exist (for any reason) for the same underlying C++ type, +those objects must be indistinguishable from one another by anything other than their address. + +The ``type_identity`` object for a given C++ type can be obtained by using the ``get`` method of the ``df::identity_trait`` +trait class. +More specifically, ``identity_traits::get()`` will return a pointer to a ``type_identity`` object for the type ``T``. +Developers who create new type identities must *either* provide an specialization of ``identity_traits`` that implements +a ``get`` method that returns the correct ``type_identity`` +*or* ensure that a static instance of ``T::_identity`` exists for the type ``T`` +(which will result in a template in :source:`DataDefs.h ` providing +an implementation of ``get`` for that type). +Note that this is only possible for compound types, and is the way that the *vast* majority of +compound types have their identities specified (including all of those defined via codegen). + +Because objects in the Lua environment are constructed as a pointer to the data and +a pointer to the data's ``type_identity`` object, it is necessary for ``type_identity`` objects to have a lifetime +that exceeds the lifetime in the Lua environment of any object that exists anywhere in the Lua environment. +It is therefore advised to avoid creating ``type_identity`` objects that do *not* have program lifetime, since +predicting the lifetime of objects in the Lua environment can be difficult. +If it is necessary to create a ``type_identity`` object that will not have program lifetime, +it is incumbent on the developer to ensure that no references to that type identity object persist beyond its lifetime. + +Due to the way template types are implemented in the C++ compilers we use for Dwarf Fortress, any specialization of one +of the type identity classes noted above as a template must at present be statically constructed in the DFHack core. +This is because we export the statically constructed instances from the core library to plugins, which then imports them +from the core library instead of instantiating them locally. As a result, referencing an instance in a plugin that has +not been instantiated in the core will result in linkage errors when linking the plugin to the core library. + +We could instead *not* export the templated types, and thus their statically constructed identity objects, +and instead allow the compiler to instantiate a local copy of these instances while compiling a plugin, +but this would definitely result in a violation of the current requirement that there be at most one instance of the +type identity object for a given C++ type across the entire program (including plugins loaded as a shared library). + +For primitive and opaque types the static constructors of the identity types +are generally found in :source:`DataIdentity.h ` +or :source:`DataIdentity.cpp `. +Types defined by Dwarf Fortress are constructed in the header files and the related ``static*.inc`` files created by codegen, +which are included into DFHack via :source:`DataStatics.cpp `. + +Some plugins (e.g. :source:`blueprint `) also define their own type identities. Type identities in plugins should be used with caution, +because the DFHack plugin model allows plugins to be unloaded on request. +Since the ``type_identity`` object is constructed within the the plugin's address space, and Lua objects that reference +this ``type_identity`` object will hold a (borrowed) pointer to that object, +unloading the plugin will result in a dangling pointer reference within the Lua environment. +It is, at present, incumbent on plugin authors to ensure that they do not use plugin defined type identities on objects +that may persist in the Lua environment beyond the lifetime of the plugin. +Declaring a ``struct_identity`` in a plugin that is the child of another ``struct_identity`` will also result in +a potentially dangling reference to that identity in the ``child`` vector of the parent identity, which means this +must also be approached with caution. + +A final note: because most instances of ``type_identity`` are statically constructed +and their construction is scattered across multiple translation units, it is, in general, *not* safe to cross-reference +the contents of one statically-defined ``type_identity`` instance during the static instantiation of another, +because the order in which statically constructed objects are instantiated in C++ is unspecified for objects defined in different translation units. +Specifically, this means that the constructor for a ``type_identity`` instance must use care in using +``df::identity_traits::get`` to use values from the identity object +of some other type, because that type's identity object may not have been constructed yet. +The ``get`` operation itself is safe, but the pointer returned by ``get`` may point to not-yet-initialized data +until at-start static data initialization is fully complete. + +Namespaces +========== + +The type identity system formally lives in the ``DFHack`` namespace. +However, because the types created by the codegen process live in the ``df`` namespace, +the identities needed to describe types coming from Dwarf Fortress are also imported into the ``df`` namespace. +When defining a new ``type_identity`` class for the purposes of supporting a new category of types coming from codegen, +remember to add an appropriate ``using`` clause to the list in :source:`DataDefs.h `. + +The ``identity_traits``, ``enum_traits``, ``bitfield_traits``, and ``enum_fields`` type traits +are defined in the ``df`` namespace. + +Type traits +=========== + +``identity_traits`` +------------------- +This type trait has two members: + +* ``static const type_identity * get()``: This function returns a pointer to the ``type_identity`` for the type ``T``. +* ``is_primitive``: true if the type is a "primitive type" (except false for enums) + +While not a type trait *per se*, the ``allocate`` template function is defined for all types +as ``return (T*)identity_traits::get()->allocate()`` and provides a convenient way to +reference the allocator in a type's ``type_identity``. + +An additional note: Conceptually, ``Lua::Push`` and ``identity_traits::get->lua_read`` are equivalent, but this is aspirational rather than actual. +There are several types for which ``Lua::Push`` has specializations that do something different than what ``type_identity::lua_read`` does for the same type. + + +``enum_traits`` +--------------- +This type trait has the following members: + +* ``is_complex``: enum is a "complex enum" +* ``enum_type`` (type): the type of the enum +* ``base_type`` (type): the underlying integral type of the enum +* ``complex``: (complex enums only) an ``DFHack::enum_identity::ComplexData`` that describes the enum +* ``is_valid(base_type value)``: (simple enums only) a function that returns a bool indicating whether ``value`` is "in range" for the enum +* ``first_item``: (simple enums only) the least valid value of the enum +* ``last_item``: (simple enums only) the greatest valid value of the enum +* ``key_table``: (simple enums only) a static array of ``const char *`` strings that correspond to the possible values of the enum + +``bitfield_traits`` +------------------- +(TODO) + +``enum_fields`` +--------------- +(TODO) diff --git a/docs/dev/github-workflows.rst b/docs/dev/github-workflows.rst new file mode 100644 index 0000000000..ea71e1a2b6 --- /dev/null +++ b/docs/dev/github-workflows.rst @@ -0,0 +1,204 @@ +GitHub workflows +================ + +We run our continuous integration (CI) validation and our release automation +via GitHub workflows. This allows us to merge PRs with confidence that they +won't catastrophically break DFHack functionality. GitHub workflows also allow +us to quickly produce stable release builds with fewer manual steps. Reducing +manual steps for releases is important since it is easy for a person to forget +a small but impactful step and therefore produce a bad release that causes +trouble for our users. + +Background +---------- + +`GitHub workflows `_ run +on provisioned VMs in the cloud with stable environments that we specify. They +are free to use since DFHack is an open source project. They have proven to be +reliably available within a few seconds when our workflows are triggered. The +logic for the workflows is written in yaml, and the files that control our +workflows are stored in the :file:`.github/workflows/` directory in each of our +repos. Example: :source:`.github/workflows`. + +Each workflow contains metadata that specifies: +- when it `triggers `_ +- what `base environment `_ it uses (OS, pre-installed dependencies, etc.) +- what additional dependencies should be installed (if any) +- custom business logic + +Workflows run in the context of a single repo, but workflows defined in one +repo can inherit logic from workflows in other repos. All our common CI logic +is in the main DFHack/dfhack repo, but our submodules, like our ``scripts`` and +``df-structures`` repos, have CI workflows defined that inherit from the logic +in DFHack/dfhack. That way we can fix bugs and extend functionality in one +place and have it benefit the entire org tree. + +Caches +~~~~~~ + +GitHub also provides 10GB per repository for `caches `_. +We utilize the cache system to keep state between workflow runs, cache +downloads, and keep compiler output to speed up subsequent builds. Efficient +use of the cache system is a critical part of our workflow design. It allows us +to iterate on test failures in PRs in one minute instead of 20. It allows us to +put out an entire emergency release build in 5 minutes instead of 45. We have +tuned our build and test workflows to minimize spurious cache misses and keep +the fast path fast. + +Caches are namespaced by key prefixes, and we have one key prefix per build +context. For example, release builds on gcc-11 are kept in one cache namespace, +whereas test builds on gcc-11 are kept separate. MSVC release and test builds +similarly have their own namespaces. Each cache has a maximum size that is +enforced by the business logic that writes the cache data. + +In order to maintain consistency in a distributed environment, caches are +versioned. A workflow will read the latest version of the cache with its key +prefix, maybe modify the cache with new data, then write back a new version. +Caches that are not used for 2 weeks are purged from GitHub storage, but if a +repo goes over the 10GB limit, caches are deleted in LRU order until the repo +is under the storage limit again. + +CI workflows +------------ + +Build +~~~~~ + +The Build workflow is the main CI workflow. It runs on every PR and push to a +branch. The ``build.yml`` file is essentially an orchestration layer for the +logic in several other .yml files: + +- ``test.yml`` builds DFHack with the test suite enabled (but stonesense and + windows pdb files disabled) and runs the test suite. It is optimized for + speed and is intended to give PR authors quick feedback on their changes. + The test suite is executed in a real running DF game on both Linux and + Windows. The ``test`` job populates the ``test`` cache, which is used by many + other workflows for non-distributed builds. +- ``package.yml`` builds DFHack as it would be released: test suite disabled + but stonesense and windows pdb files enabled. The ``package`` job populates the ``release`` cache, which is used to build all distributed binaries. +- The ``docs`` target does a docs-only build of DFHack and reports any errors. + Doc errors would show up in the ``test`` and ``package`` builds anyway, but + the ``docs`` target runs very fast and can identify doc errors in less than + 1m. +- ``lint.yml`` runs the verification scripts in the ``ci`` directory. These + scripts check for common errors in the codebase that are not caught by the + compiler. The lint scripts are written in Python and shell script and are + intended to be run quickly and catch common errors. + +Check type sizes +~~~~~~~~~~~~~~~~ + +``check-type-sizes.yml`` is a df-structures-only workflow that checks for +changes in the sizes of types in the xml structures. It builds the +``xml-dump-type-sizes`` binary on both Linux and Windows for both the +structures in this PR and for the structures in the target merge branch. It +then runs the built binary on its native OS and compares the output. If any +type sizes have changed, the workflow generates a PR comment (via the +``comment-pr.yml`` workflow) with details. + +.. _workflows-release-automation: + +Release automation workflows +---------------------------- + +Watch DF Releases +~~~~~~~~~~~~~~~~~ + +This workflow runs every 8 minutes and checks the Steam metadata, the Itch +website, and the Bay 12 website for evidence of new releases. If a new release +is found, it generates an announcement in a private channel on the DFHack +Discord server. + +Inside the ``watch-df-releases.yml`` workflow, there are separate jobs for +watching Steam branches and watching the websites. For the Steam watcher, it +takes configuration for: + +- which branches to watch +- whether to kick off the Generate symbols workflow when a new release is found +- whether to autodeploy to Steam when the Generate symbols workflow completes + +The workflow has protections against concurrent runs, so if you suspect a new +release is out, you can manually trigger the workflow to check. If the cron +trigger happens to run the workflow at the same time, the second run will be +paused while the first run completes. + +Generate symbols +~~~~~~~~~~~~~~~~ + +This workflow can be triggered manually or by the Watch DF Releases workflow. +It downloads the specified DF version for the selected distribution platform(s) +and OS target(s), then updates the ``symbol-table`` entries in ``symbols.xml``. +If the distribution platform is Steam, it can also autodetect the DF version by +extracting the version string from the DF title screen data. + +For Linux, it always builds DFHack -- just the core library (no plugins) -- and +generates symbols via the `devel/dump-offsets` and `devel/scan-vtables` scripts. + +For Windows, we extract symbol data via static analysis, so the workflow only +builds DFHack if it needs to autodetect the DF version. + +Once the symbols.xml file is updated, the workflow commits the changes to the +specified df-structures branch and updates the xml submodule ref in the +specified DFHack/dfhack branch. If a deploy Steam branch is specified, it also +launches the Deploy to Steam workflow. + +Deploy to GitHub +~~~~~~~~~~~~~~~~ + +`github-release.yml `_ +can be triggered manually or automatically by creating a new release version +tag in git. It builds DFHack with the release configuration, packages the +aritifacts for GitHub, creates a new GitHub release, and uploads the packages +to the GitHub release page. + +It uses text in :source:`.github/release_template.md` to generate the release +notes, and appends the changelog contents for the tagged version. + +If you need to re-tag the release to fix a mistake, it will automatically run +again and replace the binaries attached to the GitHub release for the tagged +version. It will not overwrite the release notes, though, to preserve any edits +you may have made in the GitHub UI. If you *want* it to completely regenerate +the release notes, you can delete the release before you re-tag the version. + +GitHub releases end up here: https://github.com/DFHack/dfhack/releases. + +Deploy to Steam +~~~~~~~~~~~~~~~ + +`steam-deploy.yml `_ +can be triggered manually or automatically by creating a new release version +tag in git. It builds DFHack with the release configuration, packages the +aritifacts for Steam, and uploads them to the specified Steam branch. + +The workflow caches steamcmd to speed the deployment up by 30s or so. +Otherwise, steamcmd would have to be downloaded and updated every time the +workflow runs. + +Steam releases end up here: +https://partner.steamgames.com/apps/builds/2346660. The "version" you +specified for the workflow is used as the "description" for the build. + +Maintenance workflows +--------------------- + +Update submodules +~~~~~~~~~~~~~~~~~ + +`update-submodules.yml `_ +runs daily, or can be run manually as needed. It checks DFHack submodules for +new commits on the main branches and updates the submodule refs in the DFHack +develop branch. + +You generally should not run this workflow for anything other than the develop +branch, as it will overwrite any changes you have made to the submodule refs in +other branches. + +Clean up PR caches +~~~~~~~~~~~~~~~~~~ + +This workflow runs automatically whenever a PR is closed or merged. It removes +caches created for the PR so they don't take up quota. + +Note that if you merge a PR before all the workflows have completed, the caches +may be created after this workflow runs. In that case, the caches will be +orphaned and will be purged by GitHub's cache eviction policy after 2 weeks. diff --git a/docs/dev/index.rst b/docs/dev/index.rst new file mode 100644 index 0000000000..931b9bb006 --- /dev/null +++ b/docs/dev/index.rst @@ -0,0 +1,26 @@ + + +======================== +DFHack development guide +======================== + +These are pages relevant to people developing for DFHack. + +.. toctree:: + :maxdepth: 1 + + /docs/dev/Dev-intro + /docs/dev/compile/index + /docs/dev/Contributing + /docs/dev/Documentation + /docs/api/index + /docs/dev/Lua API + /docs/dev/overlay-dev-guide + /docs/dev/Structures-intro + /docs/dev/data-identity + /docs/dev/github-workflows + /docs/dev/release-process + /docs/dev/Memory-research + /docs/dev/Binpatches + /docs/dev/Remote + /docs/NEWS-dev diff --git a/docs/dev/overlay-dev-guide.rst b/docs/dev/overlay-dev-guide.rst new file mode 100644 index 0000000000..d87178bfff --- /dev/null +++ b/docs/dev/overlay-dev-guide.rst @@ -0,0 +1,461 @@ +.. _overlay-dev-guide: + +DFHack overlay dev guide +========================= + +.. highlight:: lua + +This guide walks you through how to build overlay widgets and register them with +the `overlay` framework for injection into Dwarf Fortress viewscreens. + +Why would I want to create an overlay widget? +--------------------------------------------- + +There are both C++ and Lua APIs for creating viewscreens and drawing to the +screen. If you need very specific low-level control, those APIs might be the +right choice for you. However, here are some reasons you might want to implement +an overlay widget instead: + +#. You can draw directly to an existing viewscreen instead of creating an + entirely new screen on the viewscreen stack. This allows the original + viewscreen to continue processing uninterrupted and keybindings bound to + that viewscreen will continue to function. This was previously only + achievable by C++ plugins. +#. You'll get a free UI for enabling/disabling your widget and repositioning it + on the screen. Widget state is saved for you and is automatically restored + when the game is restarted. +#. You don't have to manage the C++ interposing logic yourself and can focus on + the business logic, writing purely in Lua if desired. + +In general, if you are writing a plugin or script and have anything you'd like +to add to an existing screen (including live updates of map tiles while the game +is unpaused), an overlay widget is probably your easiest path to get it done. If +your plugin or script doesn't otherwise need to be enabled to function, using +the overlay allows you to avoid writing any of the enable or lifecycle +management code that would normally be required for you to show info in the UI. + +Overlay widget API +------------------ + +Overlay widgets are Lua classes that inherit from ``overlay.OverlayWidget`` +(which itself inherits from `widgets.Panel `). The regular +``onInput(keys)``, ``onRenderFrame(dc, frame_rect)``, and ``onRenderBody(dc)`` +functions work as normal, and they are called when the viewscreen that the +widget is associated with does its usual input and render processing. The widget +gets first dibs on input processing. If a widget returns ``true`` from its +``onInput()`` function, the viewscreen will not receive the input. + +Overlay widgets can contain other Widgets and be as simple or complex as you +need them to be, just like you're building a regular UI element. + +There are a few extra capabilities that overlay widgets have that take them +beyond your everyday `widgets.Widget `: + +- If an ``overlay_onupdate(viewscreen)`` function is defined, it will be called + just after the associated viewscreen's ``logic()`` function is called (i.e. + a "tick" or a (non-graphical) "frame"). For hotspot widgets, this function + will also get called after the top viewscreen's ``logic()`` function is + called, regardless of whether the widget is associated with that viewscreen. + If this function returns ``true``, then the widget's ``overlay_trigger()`` + function is immediately called. Note that the ``viewscreen`` parameter will + be ``nil`` for hotspot widgets that are not also associated with the current + viewscreen. +- If an ``overlay_trigger()`` function is defined, will be called when the + widget's ``overlay_onupdate`` callback returns true or when the player uses + the CLI (or a keybinding calling the CLI) to trigger the widget. The + function must return either ``nil`` or the ``gui.Screen`` object that the + widget code has allocated, shown, and now owns. Hotspot widgets will receive + no callbacks from unassociated viewscreens until the returned screen is + dismissed. Unbound hotspot widgets **must** allocate a Screen with this + function if they want to react to the ``onInput()`` feed or be rendered. The + widgets owned by the overlay framework must not be attached to that new + screen, but the returned screen can instantiate and configure any new views + that it wants to. See the `hotkeys` DFHack logo widget for an example. + + The ``overlay_trigger()`` function enables the activation of overlay widgets + via the command line interface (CLI) or keybindings. + For example, executing ``overlay trigger notes.map_notes add Kitchen``:: + + function MyOverlayWidget:overlay_trigger(arg1, arg2) + if arg1 == 'add' then + -- Add a new note to the map + self:addSomething(arg2) + elseif arg1 == 'delete' then + self:deleteSomething(arg2) + end + end + + This allows for dynamic updates to UI overlays directly from the CLI. +- If an ``overlay_onenable()`` function is defined, it is called when the + overlay is enabled (including when the persisted state is reloaded at DF + startup). +- If an ``overlay_ondisable()`` function is defined, it is called when the + overlay is disabled. + +If the widget can take up a variable amount of space on the screen, and you want +the widget to adjust its position according to the size of its contents, you can +modify ``self.frame.w`` and ``self.frame.h`` at any time -- in ``init()`` or in +any of the callbacks -- to indicate a new size. The overlay framework will +detect the size change and adjust the widget position and layout. + +If you don't need to dynamically resize, just set ``self.frame.w`` and +``self.frame.h`` once in ``init()`` (or just leave them at the defaults). If +you don't need to render a widget on the screen at all, set your frame width +and/or height to 0. Your ``render`` function will still be called, but no +repositioning frame will be shown for the overlay in `gui/overlay`. + +Widget attributes +***************** + +The ``overlay.OverlayWidget`` superclass defines the following class attributes: + +- ``name`` + This will be filled in with the display name of your widget, in case you + have multiple widgets with the same implementation but different + configurations. You should not set this property yourself. +- ``version`` + You can set this to any string. If the version string of a loaded widget + does not match the saved settings for that widget, then the configuration + for the widget (position, enabled status) will be reset to defaults. +- ``desc`` + A short (<100 character) description of what the overlay does. This text + will be displayed in `gui/control-panel` on the "Overlays" tab. +- ``default_pos`` (default: ``{x=-2, y=-2}``) + Override this attribute with your desired default widget position. See + the `overlay` docs for information on what positive and negative numbers + mean for the position. Players can change the widget position at any time + via the `overlay position ` command, so don't assume that your + widget will always be at the default position. +- ``default_enabled`` (default: ``false``) + Override this attribute if the overlay should be enabled by default if it + does not already have a state stored in ``dfhack-config/overlay.json``. +- ``viewscreens`` (default: ``{}``) + The list of viewscreens that this widget should be associated with. When + one of these viewscreens is on top of the viewscreen stack, your widget's + callback functions for update, input, and render will be interposed into the + viewscreen's call path. The name of the viewscreen is the name of the DFHack + class that represents the viewscreen, minus the ``viewscreen_`` prefix and + ``st`` suffix. For example, the fort mode main map viewscreen would be + ``dwarfmode`` and the adventure mode map viewscreen would be + ``dungeonmode``. If there is only one viewscreen that this widget is + associated with, it can be specified as a string instead of a list of + strings with a single element. If you only want your widget to appear in + certain contexts, you can specify a focus path, in the same syntax as the + `keybinding` command. For example, ``dwarfmode/Info/CREATURES/CITIZEN`` will + ensure the overlay widget is only displayed when the "Citizens" subtab under + the "Units" panel is active. +- ``hotspot`` (default: ``false``) + If set to ``true``, your widget's ``overlay_onupdate`` function will be + called whenever the `overlay` plugin's ``plugin_onupdate()`` function is + called (which corresponds to one call per call to the current top + viewscreen's ``logic()`` function). This call to ``overlay_onupdate`` is in + addition to any calls initiated from associated interposed viewscreens and + will come after calls from associated viewscreens. +- ``fullscreen`` (default: ``false``) + If set to ``true``, no widget frame will be drawn in `gui/overlay` for drag + and drop repositioning. Overlay widgets that need their frame positioned + relative to the screen and not just the scaled interface area should set + this to ``true``. +- ``full_interface`` (default: ``false``) + If set to ``true``, no widget frame will be drawn in `gui/overlay` for drag + and drop repositioning. Overlay widgets that need access to the whole + scaled interface area should set this to ``true``. +- ``overlay_onupdate_max_freq_seconds`` (default: ``5``) + This throttles how often a widget's ``overlay_onupdate`` function can be + called (from any source). Set this to the largest amount of time (in + seconds) that your widget can take to react to changes in information and + not annoy the player. Set to 0 to be called at the maximum rate. Be aware + that running more often than you really need to will impact game FPS, + especially if your widget can run while the game is unpaused. If you change + the value of this attribute dynamically, it may not be noticed until the + previous timeout expires. However, if you need a burst of high-frequency + updates, set it to ``0`` and it will be noticed immediately. + +Common widget attributes such as ``active`` and ``visible`` are also respected. +Note that those properties are checked *after* matching ``viewscreens`` focus +string(s), so you can assume they are evaluated in an consistent context. For +example, if your widget has ``viewscreens='dwarfmode/Trade/Default'``, then you +can assume your ``visible=function() ... end`` function will be executing while +the trade screen is active. + +Registering a widget with the overlay framework +*********************************************** + +Anywhere in your code after the widget classes are declared, define a table +named ``OVERLAY_WIDGETS``. The keys are the display names for your widgets and +the values are the widget classes. For example, the `dwarfmonitor` widgets are +declared like this:: + + OVERLAY_WIDGETS = { + cursor=CursorWidget, + date=DateWidget, + misery=MiseryWidget, + weather=WeatherWidget, + } + +When the `overlay` plugin is enabled, it scans all plugins and scripts for +this table and registers the widgets on your behalf. Plugin lua code is loaded +with ``require()`` and script lua code is loaded with ``reqscript()``. +If your widget is in a script, ensure your script can be +`loaded as a module `, or else the widget will not be discoverable. +Whether the widget is enabled and the widget's position is restored according +to the state saved in the :file:`dfhack-config/overlay.json` file. + +The overlay framework will instantiate widgets from the named classes and own +the resulting objects. The instantiated widgets must not be added as subviews to +any other View, including the Screen views that can be returned from the +``overlay_trigger()`` function. + +Performance considerations +************************** + +Overlays that do any processing or rendering during unpaused gameplay (that is, +nearly all of them) must be developed with performance in mind. DFHack has an +overall service level objective of no more than 10% performance impact during +unpaused gameplay with all overlays and background tools enabled. A single +overlay should seek to take up no more than a fraction of 1% of elapsed +gameplay time. + +Please see the Core `performance-monitoring` section for details on how to get +a perf report while testing your overlay. The metric that you will be +interested in is the percentage of elapsed time that your overlay accounts for. + +If you need to improve performance, here are some potential options: + +1. Shard scanning over multiple passes. For example, instead of checking every + item on the map in every update in your overlay, only check every Nth item + and change the start offset every time you scan. + +2. Reduce the frequency of state updates by moving calcuations to + ``overlay_onupdate`` and setting the value of the + ``overlay_onupdate_max_freq_seconds`` attribute appropriately + +3. Move hotspots into C++ code, either in a new core library function or in a + dedicated plugin + +Overlay framework API +--------------------- + +The overlay plugin Lua interface provides a few functions for interacting with +the framework. You can get a reference to the API via:: + + local overlay = require('plugins.overlay') + +* ``overlay.rescan()`` + + Rescans all module-loadable Lua scripts for registered overlays and loads + updated widget definitions. + +* ``overlay.isOverlayEnabled(name)`` + + Returns whether the overlay with the given name is enabled. + +Development workflows +--------------------- + +When you are developing an overlay widget, you will likely need to reload your +widget many times as you make changes. The process for this differs slightly +depending on whether your widget is attached to a plugin or is implemented in a +script. + +Note that reloading a script does not clear its global environment. This is fine +if you are changing existing functions or adding new ones. If you remove a +global function or other variable from the source, though, it will stick around +in your script's global environment until you restart DF or run +`devel/clear-script-env`. + +Scripts +******* + +#. Edit the widget source +#. If the script is not in your `script-paths`, install your script (see the + `modding-guide` for help setting up a dev environment so that you don't need + to reinstall your scripts after every edit). +#. Call ``:lua require('plugins.overlay').rescan()`` to reload your overlay + widget + +Plugins +******* + +#. Edit the widget source +#. Install the plugin so that the updated code is available in + :file:`hack/lua/plugins/` +#. If you have changed the compiled plugin, `reload` it +#. If you have changed the lua code, run ``:lua reload('plugins.mypluginname')`` +#. Call ``:lua require('plugins.overlay').rescan()`` to reload your overlay + widget + +Troubleshooting +--------------- + +You can check that your widget is getting discovered by the overlay framework +by running ``overlay list`` or by launching `gui/control-panel` and checking +the ``Overlays`` tab. + +**If your widget is not listed, double check that:** + +#. ``OVERLAY_WIDGETS`` is declared, is global (not ``local``), and references + your widget class +#. (if a script) your script is `declared as a module ` + (``--@ module = true``) and it does not have side effects when loaded as a + module (i.e. you check ``dfhack_flags.module`` and return before executing + any statements if the value is ``true``) +#. your code does not have syntax errors -- run + ``:lua ~reqscript('myscriptname')`` (if a script) or + ``:lua ~require('plugins.mypluginname')`` (if a plugin) and make sure there + are no errors and the global environment contains what you expect. + +**If your widget is not running when you expect it to be running,** run +`gui/overlay` when on the target screen and check to see if your widget is +listed when showing overlays for the current screen. If it's not there, verify +that this screen is included in the ``viewscreens`` list in the widget class +attributes. Also, load `gui/control-panel` and make sure your widget is enabled. + +Widget example 1: adding text to a DF screen +-------------------------------------------- + +This is a simple widget that displays a message at its position. The message +text is retrieved from the host script or plugin every ~20 seconds or when +the :kbd:`Alt`:kbd:`Z` hotkey is hit:: + + local overlay = require('plugins.overlay') + local widgets = require('gui.widgets') + + MessageWidget = defclass(MessageWidget, overlay.OverlayWidget) + MessageWidget.ATTRS{ + desc='Sample widget that displays a message on the screen.', + default_pos={x=5,y=-2}, + default_enabled=true, + viewscreens={'dwarfmode', 'dungeonmode'}, + overlay_onupdate_max_freq_seconds=20, + } + + function MessageWidget:init() + self:addviews{ + widgets.Label{ + view_id='label', + text='', + }, + } + end + + function MessageWidget:overlay_onupdate() + local text = getImportantMessage() -- defined in the host script/plugin + self.subviews.label:setText(text) + self.frame.w = #text + end + + function MessageWidget:onInput(keys) + if keys.CUSTOM_ALT_Z then + self:overlay_onupdate() + return true + end + return MessageWidget.super.onInput(self, keys) + end + + OVERLAY_WIDGETS = {message=MessageWidget} + +Widget example 2: highlighting artifacts on the live game map +------------------------------------------------------------- + +This widget is not rendered at its "position" at all, but instead monitors the +map and overlays information about where artifacts are located. Scanning for +which artifacts are visible on the map can slow, so that is only done every 10 +seconds to avoid slowing down the entire game on every frame. + +:: + + local overlay = require('plugins.overlay') + local widgets = require('gui.widgets') + + ArtifactRadarWidget = defclass(ArtifactRadarWidget, overlay.OverlayWidget) + ArtifactRadarWidget.ATTRS{ + desc='Sample widget that highlights artifacts on the game map.', + default_enabled=true, + viewscreens={'dwarfmode', 'dungeonmode'}, + frame={w=0, h=0}, + overlay_onupdate_max_freq_seconds=10, + } + + function ArtifactRadarWidget:overlay_onupdate() + self.visible_artifacts_coords = getVisibleArtifactCoords() + end + + function ArtifactRadarWidget:onRenderFrame() + for _,pos in ipairs(self.visible_artifacts_coords) do + -- highlight tile at given coordinates + end + end + + OVERLAY_WIDGETS = {radar=ArtifactRadarWidget} + +Widget example 3: corner hotspot +-------------------------------- + +This hotspot reacts to mouseover events and launches a screen that can react to +input events. The hotspot area is a 2x2 block near the lower right corner of the +screen (by default, but the player can move it wherever). + +:: + + local overlay = require('plugins.overlay') + local widgets = require('gui.widgets') + + HotspotMenuWidget = defclass(HotspotMenuWidget, overlay.OverlayWidget) + HotspotMenuWidget.ATTRS{ + desc='Sample widget that reacts to mouse hover.', + default_pos={x=-3,y=-3}, + default_enabled=true, + frame={w=2, h=2}, + hotspot=true, + viewscreens='dwarfmode', + overlay_onupdate_max_freq_seconds=0, -- check for mouseover every tick + } + + function HotspotMenuWidget:init() + -- note this label only gets rendered on the associated viewscreen + -- (dwarfmode), but the hotspot is active on all screens + self:addviews{widgets.Label{text={'!!', NEWLINE, '!!'}}} + self.mouseover = false + end + + function HotspotMenuWidget:overlay_onupdate() + local hasMouse = self:getMousePos() + if hasMouse and not self.mouseover then -- only trigger on mouse entry + self.mouseover = true + return true + end + self.mouseover = hasMouse + end + + function HotspotMenuWidget:overlay_trigger() + return MenuScreen{hotspot_frame=self.frame}:show() + end + + OVERLAY_WIDGETS = {menu=HotspotMenuWidget} + + MenuScreen = defclass(MenuScreen, gui.ZScreen) + MenuScreen.ATTRS{ + focus_path='hotspot/menu', + hotspot_frame=DEFAULT_NIL, + } + + function MenuScreen:init() + self.mouseover = false + + -- derive the menu frame from the hotspot frame so it + -- can appear in a nearby location + local frame = copyall(self.hotspot_frame) + -- ... + + self:addviews{ + widgets.Window{ + frame=frame, + autoarrange_subviews=true, + subviews={ + -- ... + }, + }, + }, + } + end diff --git a/docs/dev/release-process.rst b/docs/dev/release-process.rst new file mode 100644 index 0000000000..bef09be412 --- /dev/null +++ b/docs/dev/release-process.rst @@ -0,0 +1,209 @@ +Release process +=============== + +This page details the process we follow for beta and stable releases. + +For documentation on the related GitHub workflows, see +`workflows-release-automation`. + +Beta release +------------ + +This process pushes a pre-release build to GitHub and Steam. It is intended to +be lower-toil than the stable release process and allows us to facilitate +frequent public testing and feedback without compromising the stability of our +"stable" releases. + +1. Run the `Update submodules `_ GitHub action on the ``develop`` branch to ensure that all submodules are up to date. + +2. Update version strings in :source:`CMakeLists.txt` as appropriate. Set ``DFHACK_RELEASE`` to the *next* stable release version with an "rc#" suffix. For example, if the last stable release was "r1" then set the string to "r2rc1". If we do a second beta release before the final stable "r2" then the string would be "r2rc2". + + - Ensure the ``DFHACK_PRERELEASE`` flag is set to ``TRUE``. + - Commit and push to ``develop`` + - Set ``RELEASE`` in your environment for the commands below (e.g. ``RELEASE=51.07-r2rc1`` for bash) + +3. Tag ``develop`` (no need to tag the submodules) and push: ``git tag -a $RELEASE -m "Bump to $RELEASE"; git push --tags origin`` + + - This will automatically trigger `Deploy to Steam `_ and `Deploy to GitHub `_ build workflows. + +4. Write release notes highlights and any requests for feedback in the `draft GitHub release `_ and publish the draft. + +5. Associate release notes with the build on Steam + + - Go to the `announcement creation page `_ + - Select "A game update" + - Select "Small update / Patch notes" + - Set the "Event title" to the release version (e.g. "DFHack 51.07-r2rc1") + - Set the "Subtitle" to "DFHack pre-release (beta channel)" + - Mention release highlights in the "Summary" field + - Transcode release notes from the GitHub release into the "Event description" field + - patch notes must be in BBcode; see `converting-markdown-to-bbcode` below for how to convert our release notes to BBcode + - Click "Link to build" and select the staging branch (be sure the build has been deployed to the branch first. By the time you're done with the patch notes the build will likely be ready for you) + - Go to the Artwork tab, select "Previously uploaded images", and search for and double-click on dfhack_logo.png. Click "Upload" (even though it has already been uploaded). + - Switch to the "Publish" tab and publish! + - `Promote `_ the build to the "beta" branch (and the "testing" branch if it's newer than what is on the "testing" branch) + +6. Monitor for beta channel subscriber feedback on the Steam `community page `_ + +7. *Maybe* also post to Reddit and other announcement channels if we feel like we need to recruit more beta testers into the pool, but we should avoid posting so often that it is annoying for those who don't use Steam or just want announcements for stable releases. + +Stable release +-------------- + +This process creates a stable DFHack release meant for widespread distribution. +Stable releases come in two forms: straight from ``develop`` or from a point +release branch. + +During "normal" times, we will test out new features in beta releases until we +reach a point of stability. Then, after the ``develop`` branch is feature frozen +while we polish and fix bugs, we tag a release directly from ``develop`` +``HEAD``. + +However, if we have already started committing beta features to ``develop`` and +it becomes necessary to put out a bugfix release for a problem in an +already-released stable release, then we will create a new branch from the +stable tag, cherry-pick fixes from ``develop`` onto that branch, and spin a +release from there. After the point release is published, we'll merge the +branch back into ``develop`` and remove the release branch to clean up. + +1. Triage remaining issues/PRs in the `release project `_ + + - Don't feel pressure to merge anything risky just before a stable release. That's what beta releases are for. + +2. In your local clone of the ``DFHack/develop`` branch, make sure your checkout and all submodules (listed in :source:`.gitmodules`) are up to date with their latest public commits and have no uncommitted/unpushed local changes. + +3. Ensure that CI has not failed unexpectedly on the latest online changes: + + - https://github.com/DFHack/dfhack/commits/develop + - https://github.com/DFHack/scripts/commits/master + - https://github.com/DFHack/df-structures/commits/master + +4. Update version strings in :source:`CMakeLists.txt` as appropriate + + - Ensure the ``DFHACK_PRERELEASE`` flag is set to ``FALSE``. + - Set ``RELEASE`` in your environment for the commands below (e.g. ``RELEASE=51.07-r1``) + +5. Replace "Future" with the version number and clean up changelog entries; add new "Future" section (with headers pre-populated from the template at the top of the file): + + - ``docs/changelog.txt`` + - ``scripts/changelog.txt`` + - ``library/xml/changelog.txt`` + - ``plugins/stonesense/docs/changelog.txt`` + +6. Do a top-level build to ensure the docs build cleanly + +7. Commit/push changes to submodules and tag (``git tag -a $RELEASE -m "Bump to $RELEASE"; git push --tags origin master``) + + - ``scripts`` + - ``library/xml`` + - ``plugins/stonesense`` + +8. Commit and push changes to ``develop`` + + - Ensure that any updates you pushed to submodules are tracked in the commit to ``DFHack/develop`` + +9. Tag ``dfhack``: ``git tag -a $RELEASE -m "Bump to $RELEASE"; git push --tags origin develop`` + + - This will automatically trigger a `Deploy to Steam `_ GitHub action to the "staging" Steam branch and a `Deploy to GitHub `_ GitHub action to create a draft `release `_ from a template and attach the built artifacts. + +10. Switch to the Steam ``staging`` release channel in the Steam client (password: ``stagingstagingstaging``) and download/test the update. + + - Ensure DFHack starts DF when run from the Steam client + - Ensure the DFHack version string is accurate on the title page (should just be the release number, e.g. ``DFHack 51.07-r1``, with no git hash or warnings) + - Run `devel/check-release` + - If something goes wrong with this step, fix it, delete the tag (both from `GitHub `_ and locally (``git tag -d $RELEASE``)), re-tag, re-push, and re-test. Note that you do *not* need to remove the GitHub draft release -- the existing one will just get updated with the new tag and binaries. You *can* remove the draft release, though, if you want the release notes to get regenerated. + +11. Prep release on GitHub + + - Go to the draft `release `_ on GitHub + - Add announcements, highlights (with demo videos), etc. to the description + +12. Push develop to master (``git push origin develop:master``) + + - This will start the documentation build process and update the published "stable" docs + - Note that if this is a -r1 release, you won't be able to complete this step until a classic build is available on the Bay 12 website so the DFHack Test workflow can pass, which is a prerequisite for being able to push to ``master``. + +13. Post release notes on Steam + + - Go to the `announcement creation page `_ + - Select "A game update" + - Select "Regular update" + - Set the "Event title" to the release version (e.g. "DFHack 51.07-r1") + - Set the "Subtitle" to "DFHack stable release" + - Add list of highlights (and maybe announcements, if significant) to the "Summary" field + - Upload screenshots and demo videos via the button at the bottom of the "Previously uploaded videos" area + - Add release notes to the "Event description" field (must be in BBcode; see `converting-markdown-to-bbcode` below for how to convert our release notes to BBcode) + - Drag uploaded images/videos into their appropriate places in the announcement text (replace the GitHub URL tags, which won't work from Steam) + - If the generated release notes exceed the announcement length limits, add a link to the GitHub release page at the bottom of the announcement instead + - Click "Link to build" and select the staging branch (be sure the build has been deployed to the branch first. by the time you're done with the patch notes the build will likely be ready for you) + - the release notes will travel with the build when we promote it to other branches + - Go to the Artwork tab, select "Previously uploaded images", and search for and double-click on STABLEannouncement6.png. Click "Upload" (even though it has already been uploaded). + - Switch to the "Publish" tab and publish! + +14. Go to the `Steam builds page `_ and promote the build to the "default" branch + + - For the build that you just pushed to "staging", click the "-- Select an app branch --" drop-down and select "default" + - Click on "Preview Change" + - Commit the change (you may need to verify with 2FA) + - If the release is newer than what's on the ``beta`` and/or ``testing`` branches, set it live on those branches as well + +15. Publish the prepped GitHub release + +16. Send out release announcements + + - Announce new version in r/dwarffortress. Example: https://www.reddit.com/r/dwarffortress/comments/1i3l5xl/dfhack_5015r2_released_highlights_stonesense/ + - Create the post in the Reddit web interface; the mobile app is extremely painful to use for posting + - Do an "Images & Video" post, sample title: "DFHack 51.07-r1 released! Hilights: Open legends mode directly from an active fort, Dig through warm or damp tiles without interruption, Unlink buildings from levers" + - Add the animated gifs to the post (with appropriate captions naming the relevant tool and what is being demonstrated) + - Add the "DFHack Official" flair to the post. If you're not a r/dwarffortress mod, ask Myk to do this after posting. + - After posting, add each section of the release notes as its own comment, splitting out individual announcements and highlights. This gives people the opportunity to respond directly to the portion of the release notes that interests them; it also helps us avoid size limits for comments. You can include a single still shot (.png file) per comment, but you have to switch to "Fancy Pants Editor" to do it. You can only switch editors once, or the image will get messed up (that is, the image will turn into a hyperlink to an image). Suggested procedure is to prepare the comment in markdown, switch to Fancy Pants Editor, and add images just before submitting the comment. + - Announce new version in forum thread. Example: http://www.bay12forums.com/smf/index.php?topic=164123.msg8567134#msg8567134 + - Update latest version text and link in `first post `_ (if you are not Lethosor, ping Lethosor for this) + - Announce in `#announcements `_ on DFHack Discord + - Announce in `#mod-releases `_ on Kitfox Discord + - Change the name of the release thread on Kitfox Discord to match the release version (if you are not Myk, ping Myk for this) + +17. Monitor all announcement channels for feedback and respond to questions/complaints + +18. Create a `project `_ on GitHub in the DFHack org for the next release + + - Open the `project template `_ + - Click "Use this template" + - Name the project according to the version, e.g. "51.07-r2" and click "Use template" + - In the new project, select settings and set the visibility to Public + - Move any remaining To Do or In Progress items from last release project to next release project + - Close project for last release + +19. If this is a -r2 release or later, go to https://readthedocs.org/projects/dfhack/versions/ and "Edit" previous DFHack releases for the same DF version and mark them "Hidden" (keep the "Active" flag set) so they no longer appear on the docs version selector. + +.. _converting-markdown-to-bbcode: + +Converting Markdown to BBcode +----------------------------- + +Hopefully we can `automate `_ this in the future, but for now, here is the procedure: + +1. Get the markdown that you want to convert into some field on GitHub (can be a temporary text field that you then preview without saving) + +2. View the rendered release notes in your browser (these instructions are for Chrome, but other browsers probably have similar capabilities) + +3. Right click on the rendered text and inspect the DOM + +4. Copy the HTML element that contains the release notes + +5. Click on the "Import HTML" button on the Steam announcement form; paste in the HTML and click "Overwrite" + +6. Copy the generated BBCode out from the description field and into a text editor + +7. Fix it up: + + - Remove the "How do I download DFHack?" section -- people on Steam don't need it + - Some ``

`` elements aren't converted properly and need to be rewritten with square brackets + - Any monospaced text gets HTML tags instead of BBCode ``[code]`` tags, but you can't use them either since they force newlines. ``[tt]`` isn't supported. Any ```` tags just need to be removed entirely. + - Any ``
`` and ```` tags need to be removed + +8. Copy it all back into the description field for the announcement + +9. Click on "Preview event" to double check that it renders sanely + +10. You're done. diff --git a/docs/gen_changelog.py b/docs/gen_changelog.py new file mode 100644 index 0000000000..3b4452f625 --- /dev/null +++ b/docs/gen_changelog.py @@ -0,0 +1,5 @@ +import os, sys +sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'sphinx_extensions')) + +from dfhack.changelog import cli_entrypoint +cli_entrypoint() diff --git a/docs/guides/index.rst b/docs/guides/index.rst new file mode 100644 index 0000000000..f47f9565ce --- /dev/null +++ b/docs/guides/index.rst @@ -0,0 +1,13 @@ +=========== +User guides +=========== + +These pages are detailed guides covering DFHack tools. + +.. toctree:: + :maxdepth: 1 + + /docs/guides/modding-guide + /docs/guides/quickfort-library-guide + /docs/guides/quickfort-user-guide + /docs/guides/stonesense-art-guide diff --git a/docs/guides/modding-guide.rst b/docs/guides/modding-guide.rst new file mode 100644 index 0000000000..e93051d41a --- /dev/null +++ b/docs/guides/modding-guide.rst @@ -0,0 +1,743 @@ +.. _modding-guide: + +DFHack modding guide +==================== + +.. highlight:: lua + +What is the difference between a script and a mod? +-------------------------------------------------- + +Well, sometimes there is no difference. A mod is anything you add to the game, +which can be graphics overrides, content in the raws, DFHack scripts, or all of +the above. There are already resources out there for +`raws modding `__, so this +guide will focus more on scripts, both standalone and as an extension to +raws-based mods. + +A DFHack script is a Lua file that can be run as a command in +DFHack. Scripts can do pretty much anything, from displaying information to +enforcing new game mechanics. If you don't already know Lua, there's a great +primer at `lua.org `__. + +Why not just mod the raws? +-------------------------- + +It depends on what you want to do. Some mods *are* better to do in just the +raws. You don't need DFHack to add a new race or modify attributes. However, +DFHack scripts can do many things that you just can't do in the raws, like make +a creature that trails smoke or launch a unit into the air when they are hit +with a certain type of projectile. Some things *could* be done in the raws, but +a script is better (e.g. easier to maintain, easier to extend, and/or not prone +to side-effects). A great example is adding a syndrome when a reaction +is performed. If done in the raws, you have to create an exploding boulder as +an intermediary to apply the syndrome. DFHack scripts can add the syndrome +directly and with much more flexibility. In the end, complex mods will likely +require a mix of raw modding and DFHack scripting. + +The structure of a mod +---------------------- + +In the example below, we'll use a mod name of ``example-mod``. I'm sure your +mods will have more creative names! Mods have a basic structure that looks like +this:: + + info.txt + graphics/... + objects/... + blueprints/... + scripts_modactive/example-mod.lua + scripts_modactive/internal/example-mod/... + scripts_modinstalled/... + README.md (optional) + +Let's go through that line by line. + +- The :file:`info.txt` file contains metadata about your mod that DF will + display in-game. You can read more about this file in the + `Official DF Modding Guide `__. + It would be a good idea to give your mod a ``dfhack`` tag so players can + indentify it as requiring DFHack when they subscribe to it on the DF Steam + workshop. +- Modifications to the game raws (potentially with + `custom raw tokens `) go in the :file:`graphics/` and + :file:`objects/` folders. You can read more about the files that go in + these directories on the :wiki:`Modding` wiki page. +- Any `quickfort` blueprints included with your mod go in the + :file:`blueprints` folder. Note that your mod can *just* be blueprints and + the :file:`info.txt` file if you like. See the next section for an example. +- A control script in :file:`scripts_modactive/` directory that handles + system-level event hooks (e.g. reloading state when a world is loaded), + registering `overlays `, and + `enabling/disabling ` your mod. You can put other + scripts in this directory as well if you want them to appear as runnable + DFHack commands when your mod is active for the current world. Lua modules + that your main scripts use, but which don't need to be directly runnable by + the player, should go in a subdirectory under + :file:`scripts_modactive/internal/` so they don't show up in the DFHack + `launcher ` command autocomplete lists. +- Scripts that you want to be available before a world is loaded (i.e. on the + DF title screen) or that you want to be runnable in any world, regardless + of whether your mod is active, should go in the + :file:`scripts_modinstalled/` folder. You can also have an :file:`internal/` + subfolder in here for private modules if you like. +- Finally, a :file:`README.md` file that has more information about your mod. + If you develop your mod using version control (recommended!), that + :file:`README.md` file can also serve as your git repository documentation. + +These files end up in a subdirectory under :file:`mods/` when players copy them +in or install them from the +`Steam Workshop `__, and in +:file:`data/installed_mods/` when the mod is selected as "active" for the first +time. + +DFHack will discover scripts in your mod's ``scripts_modinstalled/`` directory +and other DFHack-relevant data files (like blueprints) regardless of whether +the mod has been marked "active" for any player world. + +What if I just want to distribute quickfort blueprints? +------------------------------------------------------- + +For this, all you need is :file:`info.txt` and your blueprints. + +.. highlight:: none + +Your :file:`info.txt` could look something like this:: + + [ID:drooble_blueprints] + [NUMERIC_VERSION:1] + [DISPLAYED_VERSION:1.0.0] + [EARLIEST_COMPATIBLE_NUMERIC_VERSION:1] + [EARLIEST_COMPATIBLE_DISPLAYED_VERSION:1.0.0] + [AUTHOR:Drooble] + [NAME:Drooble's blueprints] + [DESCRIPTION:Useful quickfort blueprints for any occasion.] + [STEAM_TITLE:Drooble's blueprints] + [STEAM_DESCRIPTION:Useful quickfort blueprints for any occasion.] + [STEAM_TAG:dfhack] + [STEAM_TAG:quickfort] + [STEAM_TAG:blueprints] + +and your blueprints, which could be .csv or .xlsx files, would go in the +``blueprints/`` subdirectory. If you add blueprint file named +``blueprints/bedrooms.csv``, then it will be shown to players as +``drooble_blueprints/bedrooms.csv`` in `quickfort` and `gui/quickfort`. The +"drooble_blueprints" prefix comes from the mod ID specified in ``info.txt``. + +What if I just want to distribute a simple standalone script? +------------------------------------------------------------- + +If your mod is just a script with no raws modifications, all you need is:: + + info.txt + scripts_modinstalled/yourscript.lua + README.md (optional) + +Adding your script to the :file:`scripts_modinstalled/` folder will allow +DFHack to find it and add your mod to the `script-paths`. Your script will be +runnable from the title screen and in any loaded world, regardless of whether +your mod is explicitly "active". + +A mod-maker's development environment +------------------------------------- + +Create a folder for development somewhere outside your Dwarf Fortress +installation directory (e.g. ``/path/to/mymods/``). If you work on multiple +mods, you might want to make a subdirectory for each mod. + +If you have changes to the raws, you'll still have to copy them into DF's +``data/installed_mods/`` folder to have them take effect, but you can set +things up so that scripts are run directly from your dev directory. You can +edit your scripts in your dev directory and have the changes available in the +game immediately: no copying, no restarting. + +How does this magic work? Just add a line like this to your +``dfhack-config/script-paths.txt`` file:: + + +/path/to/mymods/example-mod/scripts_modinstalled + +Then that directory will be searched when you run DFHack commands from inside +the game. The ``+`` at the front of the path means to search that directory +first, before any other script directory (like :file:`hack/scripts` or other +versions of your mod in the DF mod folders). + +The structure of the game +------------------------- + +"The game", that is, all the Dwarf Fortress state, is in the global variable +`df `. Most of the information relevant to a script is found in +``df.global.world``, which contains data like the lists of active items and +units, whether to reindex pathfinding, et cetera. Also relevant to us are the +various data types found in the game, e.g. ``df.pronoun_type`` which we will be +using in this guide. We'll explore more of the game structures below. + +Your first script +----------------- + +So! It's time to write your first script. This section will walk you through how +to make a script that will get the pronoun type of the currently selected unit. +If you're not familiar with Lua script syntax, maybe skim through some topics +in the `manual `__ first. + +.. highlight:: lua + +First line, we get a reference to an in-game unit:: + + local unit = dfhack.gui.getSelectedUnit() + +If no unit is selected by the player in the DF UI, ``unit`` will be ``nil`` and +an error message will be printed. + +If ``unit`` is ``nil``, we don't want the script to run anymore:: + + if not unit then + return + end + +Now, the field ``unit.sex`` is an integer, but each integer corresponds to a +string value ("it", "she", or "he"). We get this value by indexing the +bidirectional map ``df.pronoun_type``. Indexing the other way, with one of the +strings, will yield its corresponding number. So:: + + local pronounTypeString = df.pronoun_type[unit.sex] + print(pronounTypeString) + +Simple. The entire script altogether looks like this:: + + local unit = dfhack.gui.getSelectedUnit() + if not unit then + return + end + local pronounTypeString = df.pronoun_type[unit.sex] + print(pronounTypeString) + +Save the text as a ``.lua`` file in your own scripts directory and run it from +`gui/launcher` when a unit is selected in the Dwarf Fortress UI. + +DFHack provides a vast library of functionality that make it easier to interact +with the game state. When you start asking yourself "How do I get/do X", search +through the `lua-api` for relevant functions and look through existing scripts +for examples. + +Exploring DF state +------------------ + +So how could you have known about the field and type we just used? Well, there +are two main tools for discovering the various fields in the game's data +structures. The first is the ``df-structures`` +`repository `__ that contains XML files +describing the layouts of the game's structures. These are complete, but +difficult to read (for a human). The second option is the `gui/gm-editor` +interface, an interactive data explorer. You can run the script while objects +like units are selected to view the data within them. Press :kbd:`?` while the +script is active to view help. + +Familiarising yourself with the many structs of the game will help with ideas +immensely, and you can always ask for help in the `right places `. + +Reading and writing files and other persistent state +---------------------------------------------------- + +There are several locations and APIs that a mod might need to read or store +data: + +Global state that is not world-specific should be stored in the directory +returned by the ``scriptmanager.getModStatePath()`` function. JSON is a +convenient format for this kind of stored state, and DFHack provides facilities +for reading and writing JSON data. For example:: + + local json = require('json') + local scriptmanager = require('script-manager') + local path = scriptmanager.getModStatePath('mymodname') + config = config or json.open(path .. 'settings.json') + + -- modify state in the config.data table and persist it when it changes with + -- config:write() + +State that should be saved with a world or a specific fort within that world +should use `persistent-api` API. You can attach a state change hook for new +world loaded where you can load the state, which often includes whether the mod +itself is enabled (if the mod can be dynamically enabled/disabled -- see the +`script-enable-api` for more details). For example:: + + --@ enable=true + --@ module=true + + local utils = require('utils') + + local GLOBAL_KEY = 'mymodname' + + local function get_default_state() + return { + enabled=false, + somevar=0, + somesubtable={ + someothervar=0, + }, + } + end + state = state or get_default_state() + + -- implement the enabled API so DFHack can read this script's status + function isEnabled() + return state.enabled + end + + local function persist_state() + dfhack.persistent.saveSiteData(GLOBAL_KEY, state) + end + + local function do_enable() + -- initialization tasks, such as hooking events + end + + local function do_disable() + -- cleanup tasks, such as removing event hooks + end + + dfhack.onStateChange[GLOBAL_KEY] = function(sc) + if sc == SC_MAP_UNLOADED then + do_disable() + + -- ensure our mod doesn't run when a different + -- world is loaded where we are *not* active + dfhack.onStateChange[GLOBAL_KEY] = nil + + return + end + + if sc ~= SC_MAP_LOADED or not dfhack.world.isFortressMode() then + return + end + + -- retrieve state saved in game. merge with default state so config + -- saved from previous versions can pick up newer defaults. + state = get_default_state() + utils.assign(state, dfhack.persistent.getSiteData(GLOBAL_KEY, state)) + if state.enabled then + do_enable() + end + end + +Finally, you may have distributed data files with your mod that you need to +read at runtime. Your mod directory should be treated as read-only since data +there is not backed up. Use the `script-manager` API to get the path to your +mod data and the ``json`` (or any other file I/O) API as needed. For example:: + + local scriptmanager = require('script-manager') + + local GLOBAL_KEY = 'mymodname' + + local function read_bulk_data_db() + local mod_source_path = scriptmanager.getModSourcePath(GLOBAL_KEY) + -- read data from files in the mod directory + return ... + end + + bulk_data_db = bulk_data_db or read_bulk_data_db() + +If you want to store state in the savegame so that it is associated with the +current world/fort/adventure, use the `persistent-api` API. or in the fuller example later in this +guide. + +Reacting to events +------------------ + +The common method for injecting new behaviour into the game is to define a +callback function and get it called when something interesting happens. DFHack +provides two libraries for this, ``repeat-util`` and `eventful `. +``repeat-util`` is used to run a function once per a configurable number of +frames (paused or unpaused), ticks (unpaused), in-game days, months, or years. +If you need to be aware the instant something happens, you'll need to run a +check once a tick. Be careful not to do this gratuitously, though, since +running callbacks too often can significantly slow down the game! + +``eventful``, on the other hand, is much more performance-friendly since it will +only call your callback when a relevant event happens, like a reaction +occuring, a job being completed, or a projectile moving to a new tile. + +To get something to run once every 1000 ticks, we can call +``repeat-util.scheduleEvery()``. First, we load the module:: + + local repeatUtil = require('repeat-util') + +Both ``repeat-util`` and ``eventful`` require keys for registered callbacks. You +should use something unique, like your mod id:: + + local GLOBAL_KEY = 'mymodname' + +Then, we pass the key, amount of time units between function calls, what the +time units are, and finally the callback function itself:: + + repeatUtil.scheduleEvery(GLOBAL_KEY, 1000, 'ticks', function() + -- Do something like iterating over all active units and + -- check for something interesting + for _, unit in ipairs(df.global.world.units.active) do + ... + end + end) + +``eventful`` is slightly more involved. First get the module:: + + local eventful = require('plugins.eventful') + +``eventful`` contains a table for each event which you populate with functions. +Each function in the table is then called with the appropriate arguments when +the event occurs. So, for example, to print the position of a moving (item) +projectile:: + + eventful.onProjItemCheckMovement[GLOBAL_KEY] = function(projectile) + print(projectile.cur_pos.x, projectile.cur_pos.y, + projectile.cur_pos.z) + end + +Check out the `full list of supported events ` to see what else +you can react to with ``eventful``. + +Now, you may have noticed that you won't be able to register multiple callbacks +with a single key named after your mod. You can, of course, call all the +functions you want from a single registered callback. Alternately, you can +create multiple callbacks using different keys, using your mod ID as a key name +prefix. If you do register multiple callbacks, though, there are no guarantees +about the call order. + +Custom raw tokens +----------------- + +.. highlight:: none + +In this section, we are going to use `custom raw tokens ` +applied to a reaction to transfer the material of a reagent to a product as a +handle improvement (like on artifact buckets). As a second example, we are +going to make boots that make units go faster when worn. + +First, let's define raws for a custom crossbow with its own custom reaction. The +crossbow:: + + [ITEM_WEAPON:ITEM_WEAPON_CROSSBOW_SIEGE] + [NAME:crossbow:crossbows] + [SIZE:600] + [SKILL:HAMMER] + [RANGED:CROSSBOW:BOLT] + [SHOOT_FORCE:4000] + [SHOOT_MAXVEL:800] + [TWO_HANDED:0] + [MINIMUM_SIZE:17500] + [MATERIAL_SIZE:4] + [ATTACK:BLUNT:10000:4000:bash:bashes:NO_SUB:1250] + [ATTACK_PREPARE_AND_RECOVER:3:3] + [SIEGE_CROSSBOW_MOD_FIRE_RATE_MULTIPLIER:2] custom token (you'll see) + +The reaction to make it (you would add the reaction and not the weapon to an +entity raw):: + + [REACTION:MAKE_SIEGE_CROSSBOW] + [NAME:make siege crossbow] + [BUILDING:BOWYER:NONE] + [SKILL:BOWYER] + [REAGENT:mechanism 1:2:TRAPPARTS:NONE:NONE:NONE] + [REAGENT:bar:150:BAR:NONE:NONE:NONE] + [METAL_ITEM_MATERIAL] + [REAGENT:handle 1:1:BLOCKS:NONE:NONE:NONE] wooden handles + [ANY_PLANT_MATERIAL] + [REAGENT:handle 2:1:BLOCKS:NONE:NONE:NONE] + [ANY_PLANT_MATERIAL] + [SIEGE_CROSSBOW_MOD_TRANSFER_HANDLE_MATERIAL_TO_PRODUCT_IMPROVEMENT:1] + another custom token + [PRODUCT:100:1:WEAPON:ITEM_WEAPON_CROSSBOW_SIEGE:GET_MATERIAL_FROM_REAGENT:bar:NONE] + +So, we are going to use the ``eventful`` module to react when this crossbow is +crafted, allowing us to inject the logic that will add the handle improvement. + +.. highlight:: lua + +First, require the modules we are going to use:: + + local eventful = require('plugins.eventful') + local customRawTokens = require('custom-raw-tokens') + +and attach a callback to the event:: + + local GLOBAL_KEY = 'mymodname' + + local function reaction_handler(reaction, reactionProduct, unit, + inputItems, inputReagents, outputItems) + -- we'll be defining the body of this function below + end + + eventful.onReactionComplete[GLOBAL_KEY] = reaction_handler + +Now let's look at the ``reaction_handler`` function and give it some logic. +First, we check to see if it the reaction that just happened is relevant to this +callback:: + + if not customRawTokens.getToken(reaction, + 'SIEGE_CROSSBOW_MOD_TRANSFER_HANDLE_MATERIAL_TO_PRODUCT_IMPROVEMENT') + then + return + end + +Then, we check the reagents for names that start with "handle". For those +reagents, we get the corresponding item and add a handle improvement:: + + for i, reagent in ipairs(inputReagents) do + if reagent.code:startswith('handle') then + -- Found handle reagent + local item = inputItems[i] + local improv = df.itemimprovement_itemspecificst:new() + improv.mat_type, improv.mat_index = item.mat_type, item.mat_index + improv.type = df.itemimprovement_specific_type.HANDLE + outputItems[1].improvements:insert('#', improv) + end + end + +Let's also modify the fire rate of our siege crossbow according to the custom +token we added to the item definition in the raws:: + + eventful.onProjItemCheckMovement[GLOBAL_KEY] = function(projectile) + if projectile.distance_flown > 0 then + -- don't make this adjustment more than once + return + end + + local firer = projectile.firer + if not firer then + return + end + + local weapon = df.item.find(projectile.bow_id) + if not weapon then + return + end + + local multiplier = tonumber(customRawTokens.getToken( + weapon.subtype, + 'SIEGE_CROSSBOW_MOD_FIRE_RATE_MULTIPLIER')) or 1 + firer.counters.think_counter = math.floor( + firer.counters.think_counter * multiplier) + end + +.. highlight:: none + +Now, let's see how we could make some "pegasus boots". First, let's define the +item in the raws:: + + [ITEM_SHOES:ITEM_SHOES_BOOTS_PEGASUS] + [NAME:pegasus boot:pegasus boots] + [ARMORLEVEL:1] + [UPSTEP:1] + [METAL_ARMOR_LEVELS] + [LAYER:OVER] + [COVERAGE:100] + [LAYER_SIZE:25] + [LAYER_PERMIT:15] + [MATERIAL_SIZE:2] + [METAL] + [LEATHER] + [HARD] + [PEGASUS_BOOTS_MOD_FOOT_MOVEMENT_TIMER_REDUCTION_PER_TICK:2] custom raw token + (you don't have to comment the custom token every time, + but it does clarify what it is) + +.. highlight:: lua + +Then, let's define a function that will implement the logic associated with the +boots:: + + local function do_pegasus() + for _,unit in ipairs(df.global.world.units.active) do + local amount = 0 + for _,inv_entry in ipairs(unit.inventory) do + if inv_entry.mode == df.unit_inventory_item.T_mode.Worn then + local reduction = customRawTokens.getToken( + inv_entry.item, + 'PEGASUS_BOOTS_MOD_FOOT_MOVEMENT_TIMER_REDUCTION_PER_TICK') + amount = amount + (tonumber(reduction) or 0) + end + end + -- Subtract amount from on-foot movement timers if not on ground + if not unit.flags1.on_ground then + dfhack.units.subtractActionTimers(unit, amount, + df.unit_action_type_group.MovementFeet) + end + end + end + +Finally, we can schedule the callback to be run once a tick using the +``repeat-util`` module:: + + repeatUtil.scheduleEvery(GLOBAL_KEY, 1, 'ticks', do_pegasus) + +Note that the ``do_pegasus`` function as written here is **extremely +inefficient**. In a real mod, you would likely want to cache which units are +equipping pegasus boots so you don't have to scan every inventory item of every +active unit on every tick. + +Putting it all together +----------------------- + +Ok, you're all set up! Now, let's take a look at an example +``scripts_modinstalled/example-mod.lua`` file:: + + -- main file for the example-mod mod + + -- these lines indicate that the script supports the "enable" + -- API so you can start it by running "enable example-mod" and + -- stop it by running "disable example-mod" + --@ module=true + --@ enable=true + + -- this is the help text that will appear in `help` and + -- `gui/launcher`. see possible tags here: + -- https://docs.dfhack.org/en/stable/docs/Tags.html + --[====[ + example-mod + =========== + + Tags: fort | gameplay + + Short one-sentence description. + + Longer description ... + + Usage + ----- + + enable example-mod + disable example-mod + ]====] + + local eventful = require('plugins.eventful') + local repeatUtil = require('repeat-util') + local utils = require('utils') + + -- you can reference global values or functions declared in any of + -- your internal modules + local moduleA = reqscript('internal/example-mod/module-a') + local moduleB = reqscript('internal/example-mod/module-b') + + local GLOBAL_KEY = 'example-mod' + + local function get_default_state() + return { + enabled=false, + somevar=0, + somesubtable={ + someothervar=0, + }, + } + end + state = state or get_default_state() + + -- implement the enabled API so DFHack can read this script's status + function isEnabled() + return state.enabled + end + + -- call this whenever the contents of the state table changes + local function persist_state() + dfhack.persistent.saveSiteData(GLOBAL_KEY, state) + end + + local function do_enable() + -- do any initialization your internal scripts might require + moduleA.onEnable() + moduleB.onEnable() + + repeatUtil.scheduleEvery(GLOBAL_KEY, 1000, 'ticks', function() + moduleA.cycle() + moduleB.cycle() + end) + + eventful.onProjItemCheckMovement[GLOBAL_KEY] = + moduleB.onProjItemCheckMovement + eventful.onProjUnitCheckImpact[GLOBAL_KEY] = + moduleB.onProjUnitCheckImpact + end + + local function do_disable() + -- call any shutdown functions your internal scripts might require + moduleA.onDisable() + moduleB.onDisable() + + repeatUtil.cancel(GLOBAL_KEY) + + eventful.onProjItemCheckMovement[GLOBAL_KEY] = nil + eventful.onProjUnitCheckImpact[GLOBAL_KEY] = nil + end + + dfhack.onStateChange[GLOBAL_KEY] = function(sc) + if sc == SC_MAP_UNLOADED then + do_disable() + + -- ensure our mod doesn't run when a different + -- world is loaded where we are *not* active + dfhack.onStateChange[GLOBAL_KEY] = nil + + return + end + + if sc ~= SC_MAP_LOADED or not dfhack.world.isFortressMode() then + return + end + + -- retrieve state saved in game. merge with default state so config + -- saved from previous versions can pick up newer defaults. + state = get_default_state() + utils.assign(state, dfhack.persistent.getSiteData(GLOBAL_KEY, state)) + if state.enabled then + do_enable() + end + end + + if dfhack_flags.module then + return + end + + if not dfhack_flags.enable then + print(dfhack.script_help()) + print() + print(('Example mod is currently '):format( + enabled and 'enabled' or 'disabled')) + return + end + + if dfhack_flags.enable_state then + state.enabled = true + do_enable() + else + state.enabled = false + do_disable() + end + + persist_state() + +The ``scripts_modinstalled/internal/example-mod/module-a.lua`` file could look +something like this:: + + --@ module=true + + -- global (non-local) variables and functions are exported + function onEnable() + -- ... + end + + function onDisable() + -- ... + end + + -- this is a local function: local functions/variables + -- are not accessible to other scripts. + local function usedByCycle(unit) + -- ... + end + + function cycle() -- exported + for _,unit in ipairs(df.global.world.units.active) do + usedByCycle(unit) + end + end + +The `reqscript ` function reloads scripts that have changed, so you +can modify your scripts while DF is running and just disable/enable your mod to +load the changes into your running game! diff --git a/docs/guides/quickfort-library-guide.rst b/docs/guides/quickfort-library-guide.rst new file mode 100644 index 0000000000..e363fe0987 --- /dev/null +++ b/docs/guides/quickfort-library-guide.rst @@ -0,0 +1,232 @@ +.. _blueprint-library-guide: +.. _quickfort-library-guide: + +Quickfort blueprint library +=========================== + +This guide contains a high-level overview of the blueprints available in the +:source:`quickfort blueprint library `. + +Each file is hyperlinked to its online version so you can see exactly what the +blueprints do before you run them. Also, if you use `gui/quickfort`, you will +get a live preview of which tiles will be modified by the blueprint before you +apply it to your map. + +Whole fort blueprint sets +------------------------- + +These files contain the plans for entire fortresses. Each file has one or more +help sections that walk you through how to build the fort, step by step. + +- :source:`library/dreamfort.csv ` + +.. _dreamfort: + +Dreamfort +~~~~~~~~~ + +Dreamfort is a fully functional, self-sustaining fortress with defenses, +farming, a complete set of workshops, self-managing quantum stockpiles, a grand +dining hall, hospital (werecreature-ready), library, temple, jail, fresh water +well system, guildhalls, noble suites, and bedrooms for hundreds of dwarves. It +also comes with manager work orders to automate basic fort needs, such as food, +booze, and item production. It can function by itself or as the core of a +larger, more ambitious fortress. Read the walkthrough by running +`gui/quickfort`, searching for ``dreamfort help``, and selecting the blueprints. + +Dreamfort blueprints are available for easy viewing and copying `online +`__. + +The online spreadsheets also include `embark profile suggestions +`__, +a complete `example embark profile +`__, +and a convenient `checklist +`__ +that you can use to track your progress. + +If you'd like a visual demonstration, there is a `series of videos on YouTube `__ +that walk you through the entire process of building a Dreamfort-based +fortress. You can also download a fully built Dreamfort-based fort from +:dffd:`dffd <15434>`, load it, and explore it interactively. + +Here are annotated screenshots of the major Dreamfort levels (or click `here +`__ +for a slideshow). + +Surface level +````````````` + +.. image:: https://lh3.googleusercontent.com/d/1dlu3nmwQszav-ZaTx-ac28wrcaYBQc_t + :alt: Annotated screenshot of the dreamfort surface level + :target: https://drive.google.com/file/d/1dlu3nmwQszav-ZaTx-ac28wrcaYBQc_t + :align: center + +Farming level +````````````` + +.. image:: https://lh3.googleusercontent.com/d/1vDaedLcgoexUdKREUz75ZXQi0ZSdwWwj + :alt: Annotated screenshot of the dreamfort farming level + :target: https://drive.google.com/file/d/1vDaedLcgoexUdKREUz75ZXQi0ZSdwWwj + :align: center + +Industry level +`````````````` + +.. image:: https://lh3.googleusercontent.com/d/1c8YTHxTgJY5tUII-BOWdLhmDFAHwIOEs + :alt: Annotated screenshot of the dreamfort industry level + :target: https://drive.google.com/file/d/1c8YTHxTgJY5tUII-BOWdLhmDFAHwIOEs + :align: center + +Services levels (4 deep) +```````````````````````` + +.. image:: https://lh3.googleusercontent.com/d/1RQMy_zYQWM5GN7-zjn6LoLWmnrJjkxPM + :alt: Annotated screenshot of the dreamfort services level + :target: https://drive.google.com/file/d/1RQMy_zYQWM5GN7-zjn6LoLWmnrJjkxPM + :align: center + +**Example plumbing to fill cisterns** + +If you are routing water to fill the cisterns, you can do it like this: + +.. image:: https://lh3.googleusercontent.com/d/1paXqPJ-7h9_jG_eNXU1z5GGvR0J8C0uJ + :alt: Annotated screenshot of an example plumbing for the dreamfort cisterns + :target: https://drive.google.com/file/d/1paXqPJ-7h9_jG_eNXU1z5GGvR0J8C0uJ + :align: center + +Cistern drain (keep open while you're digging out the aquifer tap): + +.. image:: https://lh3.googleusercontent.com/d/1SwSluJcN_kOrCYPdcFOfJ13wEDvZGcJe + :alt: Annotated screenshot of an example drainage for the dreamfort cisterns + :target: https://drive.google.com/file/d/1SwSluJcN_kOrCYPdcFOfJ13wEDvZGcJe + :align: center + +Guildhall level +``````````````` + +.. image:: https://lh3.googleusercontent.com/d/1mt66QOkfBqFLtw6AJKU6GNYmhB72XSJG + :alt: Annotated screenshot of the dreamfort guildhall level + :target: https://drive.google.com/file/d/1mt66QOkfBqFLtw6AJKU6GNYmhB72XSJG + :align: center + +Noble suites +```````````` + +.. image:: https://lh3.googleusercontent.com/d/16XRb1w5zFoyVq2LBMx_aCwOyjFq7GULc + :alt: Annotated screenshot of the dreamfort noble suites + :target: https://drive.google.com/file/d/16XRb1w5zFoyVq2LBMx_aCwOyjFq7GULc + :align: center + +Apartments +`````````` + +.. image:: https://lh3.googleusercontent.com/d/16-NXlodLIQjeZUMSmsWRafeytwU2dXQo + :alt: Annotated screenshot of the dreamfort apartments + :target: https://drive.google.com/file/d/16-NXlodLIQjeZUMSmsWRafeytwU2dXQo + :align: center + +Crypt +````` + +.. image:: https://lh3.googleusercontent.com/d/16iT_ho7BIRPD_eofuxdlVQ4FunR1Li23 + :alt: Annotated screenshot of the dreamfort crypt + :target: https://drive.google.com/file/d/16iT_ho7BIRPD_eofuxdlVQ4FunR1Li23 + :align: center + +Layout helpers +-------------- + +These files simply draw diagonal marker-mode lines starting from the cursor. +They are especially useful for finding the center of the map when you are +planning your fortress. Once you are done using them for alignment, use +``quickfort undo`` at the same cursor position to make them disappear. Since +these ``#dig`` blueprints can only mark undug wall tiles for mining, they are +best used underground. They won't do much on the surface, where there aren't +many walls. + +- :source:`library/layout-helpers/mark_up_left.csv ` +- :source:`library/layout-helpers/mark_up_right.csv ` +- :source:`library/layout-helpers/mark_down_right.csv ` +- :source:`library/layout-helpers/mark_down_left.csv ` + +Bedrooms +-------- + +These are popular bedroom layouts from the :wiki:`Bedroom design` page on the +wiki. Each file has blueprints to dig the rooms, zone them as bedrooms, and +build the furniture. + +- :source:`library/bedrooms/48-4-Raynard_Whirlpool_Housing.csv ` +- :source:`library/bedrooms/95-9-Hactar1_3_Branch_Tree.csv ` +- :source:`library/bedrooms/28-3-Modified_Windmill_Villas.csv ` + +Tombs +----- + +These blueprints have burial plot layouts for fortress that expect a lot of +casualties. + +- :source:`library/tombs/Mini_Saracen.csv ` +- :source:`library/tombs/The_Saracen_Crypts.csv ` + +Exploratory mining +------------------ + +Several mining patterns to choose from when searching for gems or ores. The +patterns can be repeated up or down z-levels (via `gui/quickfort`\'s +:kbd:`r`\epeat functionality) for exploring through the depths. + +- :source:`library/exploratory-mining/tunnels.csv ` +- :source:`library/exploratory-mining/vertical-mineshafts.csv ` +- :source:`library/exploratory-mining/connected-mineshafts.csv ` + +Miscellaneous +------------- + +Extra blueprints that are useful in specific situations. + +- :source:`library/aquifer_tap.csv ` +- :source:`library/embark.csv ` +- :source:`library/pump_stack.csv ` + +Light aquifer tap +~~~~~~~~~~~~~~~~~ + +The aquifer tap helps you create a safe, everlasting source of fresh water from +a light aquifer. See the step-by-step guide, including information on how to +create a drainage system so your dwarves don't drown when digging the tap, by +running the ``library/aquifer_tap.csv`` ``/help`` blueprint. Alternately, view +the demo video below. + +You can see how to nullify the water pressure (so you don't flood your fort) in +the Dreamfort cistern screenshot above: `Services levels (4 deep)`_. + +.. raw:: html + + + +The blueprint spreadsheet is also available +`online `__. + +Post-embark +~~~~~~~~~~~ + +The embark blueprints are useful directly after embark. It contains a ``#build`` +blueprint that builds important starting workshops (mason, carpenter, mechanic, +and craftsdwarf) and a ``#place`` blueprint that lays down a pattern of useful +starting stockpiles. + +Pump stack +~~~~~~~~~~ + +The pump stack blueprints help you move water and magma up to more convenient +locations in your fort. See the step-by-step guide for using it by running the +``library/pump_stack.csv`` ``/help`` blueprint or by viewing the demo video: + +.. raw:: html + + + +The blueprint spreadsheet is also available +`online `__. diff --git a/docs/guides/quickfort-user-guide.rst b/docs/guides/quickfort-user-guide.rst new file mode 100644 index 0000000000..dae03c3aba --- /dev/null +++ b/docs/guides/quickfort-user-guide.rst @@ -0,0 +1,2391 @@ +.. _quickfort-blueprint-guide: +.. _quickfort-user-guide: +.. _quickfort-alias-guide: + +Quickfort blueprint creation guide +================================== + +`Quickfort ` is a DFHack tool that helps you build fortresses from +"blueprint" .csv and .xlsx files. Many applications exist to edit these files, +such as MS Excel and `Google Sheets `__. Most layout and +building-oriented DF actions are supported through the use of multiple files or +spreadsheets, each describing a different phase of DF construction: designating +digging, defining zones, placing stockpiles, and building. + +The original idea came from :wiki:`Valdemar's ` auto-designation +macro. Joel Thornton reimplemented the core logic in Python and extended its +functionality with `Quickfort 2.0 `__. This +DFHack-native implementation, called "DFHack Quickfort" or just "quickfort", +builds upon Quickfort 2.0's formats and features, preserving compatibility with +existing blueprints (where possible -- DF itself has changed since then). In +contrast with the earlier quickfort implementations, which interacted with DF +by simulating keyboard input, DFHack Quickfort calls lower-level API functions +to designate tiles and configure buildings. This allows for nearly +instantaneous blueprint application, error checking and recovery, and many other +advanced features. + +This guide focuses on DFHack Quickfort's capabilities and blueprint syntax, and +teaches players how to understand and create blueprint files. Some of the text +was originally written by Joel Thornton, reused here with his permission. + +If you are just looking to apply existing blueprints to your fort, check out +`gui/quickfort` (or `quickfort` for the commandline version). There are many +ready-to-use blueprints available in the `quickfort-library-guide` distributed +with DFHack. + +Before you become an expert at writing blueprints, though, you should know that +the easiest way to make a quickfort blueprint is to build your plan "for real" +in Dwarf Fortress and then export that section of your map using +`gui/blueprint`. You can apply those blueprints as-is in your next fort, or you +can fine-tune them with additional features from this guide. + +See the `Links`_ section for more information and online resources. + +.. contents:: Table of Contents + :local: + :depth: 2 + +Feature summary +--------------- + +- General + + - Blueprint modes for all phases of fort design + - Read blueprints from .csv or multi-worksheet .xlsx files + - Near-instant application, even for very large and complex blueprints + - Blueprints can span multiple z-levels + - Easy sharing of blueprints with multi-blueprint files + - Scripted application of sequences of blueprints + - Undo applied blueprints + - Rotate blueprints or flip them around + - Automatic cropping of blueprints that extend off the map + - Generate manager orders for items required by a blueprint + - Includes a library of ready-to-use blueprints + - Blueprint debugging + +- Dig mode + + - Supports all types of designations, including dumping/forbidding items and + setting traffic settings + - Supports setting dig priorities + - Supports applying dig blueprints in marker mode + - Handles carving arbitrarily complex minecart tracks, including tracks that + cross other tracks + +- Zone and place modes + + - Define zones and stockpiles of any shape, not just rectangles + - Configurable numbers of bins, barrels and wheelbarrows assigned to created + stockpiles + - Automatic splitting of stockpiles that exceed maximum dimension limits + - Create and attach locations to zones + - Full control over stockpile configuration based on the `stockpiles` + settings library + - Configurable zone/location settings, such as the pit/pond toggle or + hospital supply quantities + +- Build mode + + - Integrated with DFHack `buildingplan`: you can place buildings before + manufacturing building materials and you can use the `buildingplan` UI + for setting materials and quality preferences + - Designate entire constructions in mid-air without having to wait for each + tile to become supported + - Automatic expansion of building footprints to their minimum dimensions, so + only the center tile of a multi-tile building needs to be recorded in the + blueprint + - Tile occupancy and validity checking so, for example, buildings that + cannot be placed on a target tile will be skipped instead of causing + errors and interrupting the blueprint. Blueprints that are only partially + applied for any reason (e.g. you need to dig out some more tiles) can be + safely reapplied to build the remaining buildings. + - Relaxed rules for farm plot and road placement: you can still place the + building even if an invalid tile (e.g. stone tiles for farm plots) splits + the designated area into two disconnected parts + - Intelligent boundary detection for adjacent buildings of the same type + (e.g. a 6x6 block of ``wj`` cells will be correctly split into 4 jeweler's + workshops) + - Set building properties (such as a name) + - Can attach and configure track stops as part of hauling routes + +- Burrow mode + + - Supports creating, adding to, and subtracting from burrows. + +Introduction to blueprints +-------------------------- + +We recommend using a spreadsheet editor such as Excel, `Google +Sheets `__, or `LibreOffice `__ +to edit blueprint files, but any text editor will do. + +The format of Quickfort-compatible blueprint files is straightforward. The first +line (or upper-left cell) of the spreadsheet should look like this:: + + #dig + +The keyword ``dig`` tells Quickfort we are going to be specifying designations. +The following "mode" keywords are understood: + +============== =========== +Blueprint mode Description +============== =========== +dig Designations (digging, traffic, dumping, etc.) +build Constructions, buildings, and furniture +place Stockpiles +zone Activity zones +============== =========== + +If no modeline appears in the first cell, Quickfort assumes that it's looking at +a ``#dig`` blueprint. + +There are also other modes that don't directly correspond to Dwarf Fortress +design operations, but we'll talk about those `later `. + +If you like, you may enter a comment after the mode keyword. This comment will +appear in the output of ``quickfort list`` or in the dialog window when running +`gui/quickfort`. You can use this space for explanations, attribution, etc.:: + + #dig grand dining room + +Below this line, begin entering keys in each spreadsheet cell that represent +what you want designated in the corresponding game map tile. For example, we +could dig out a 4x4 room like so (spaces are used as column separators here for +readability, but a real .csv file would have commas):: + + #dig + d d d d # + d d d d # + d d d d # + d d d d # + # # # # # + +The letter ``d`` here stands for "dig". The character sequences in these +blueprints are based on the old (pre-v50) keyboard shortcuts for the various DF +menus. Please see the `quickfort_guide_appendix` below for a full reference. + +Note the :kbd:`#` symbols at the right end of each row and below the last row. +These are completely optional, but can be helpful to make the row and column +positions clear. + +In general, any cell that contains text that starts with a :kbd:`#` is +interpreted as a comment and is ignored by `quickfort`. You can use this to +leave notes for yourself inside of a blueprint. Take care to start your comment +with a space after the ``#`` to avoid accidentally starting a modeline if your +comment happens to be in the first column and happens to start with a modeline +keyword. For example, ``#dig this area out`` is an accidental modeline that +will cause problems. However, ``# dig this area out`` is a safe comment. + +Once the dwarves have that dug out, let's zone it as a bedroom:: + + #zone + b b b b # + b b b b # + b b b b # + b b b b # + # # # # # + +This looks very similar to the ``#dig`` blueprint above, but with ``b``\s +instead of ``d``\s. The ``b``\s mark the area for a ``b``\edroom zone just like +the ``#dig`` blueprint marked the area for digging. It's important to wait +until after the area is completely dug out before applying further blueprints +since zones can't be applied to hidden tiles and furniture can't be built in +undug walls. + +Now, let's add some walls and furniture:: + + #build + Cw Cw Cw Cw # + Cw b h Cw # + Cw Cw # + Cw Cw Cw # + # # # # # + +The :kbd:`C`:kbd:`w` cells represent the constructed walls, leaving space for a +door that we might want to add later. Quickfort uses `buildingplan` for +managing buildings, so the walls will be built out of whatever matches the +current buildingplan filter set for walls. Also note my generosity -- in +addition to the bed (:kbd:`b`) I've built a container (:kbd:`h`) for this lucky +dwarf. + +Finally, let's place a booze stockpile in the 2 unoccupied tiles in the room:: + + #place personal booze stockpile + ` ` ` ` # + ` ~ ~ ` # + ` f f{name="bedroom booze"}:=booze + ` ` ` # + # # # # # + +This illustration may be a little hard to understand. The two :kbd:`f` +characters are in row 3, columns 2 and 3. All the other cells are empty. QF +considers both :kbd:`\`` (backtick -- the character under the tilde) and +:kbd:`~` (tilde) characters within cells to be empty cells; this can help with +multilayer or fortress-wide blueprint layouts as "chalk lines". + +QF is smart enough to recognize this as a 2x1 food stockpile, and creates it as +such rather than as two 1x1 food stockpiles. Quickfort treats any connected +region of identical designations as a single entity. The tiles can be connected +orthogonally or diagonally, just as long as they are touching. You can also +treat disconnected segments as belonging to the same stockpile, but we'll get +into `Label syntax`_ later. + +Now what's all that business attached to the second ``f``? The part between the +curly brackets specifies properties, in this case the name that we want to give +the stockpile. The remaining part, from the colon (``:``) onward, applies the +``booze`` preset from the `stockpiles` library. That will configure the +stockpile to accept only booze. You can use presets (along with other options +that we'll go over later) to configure stockpiles however you want, directly +from the ``#place`` blueprint. + +And that's it! You now have a series of blueprints that you can "stamp" across +your fort to quickly build new bedrooms. + +Area expansion syntax +~~~~~~~~~~~~~~~~~~~~~ + +In Quickfort, the following blueprints are equivalent:: + + #dig a 3x3 area + d d d # + d d d # + d d d # + # # # # + + #dig the same area with d(3x3) specified in row 1, col 1 + d(3x3)# + ` ` ` # + ` ` ` # + # # # # + +The second example uses Quickfort's "area expansion syntax", which takes the +form:: + + text(WxH) + +Note that area expansion syntax can only specify rectangular areas. If you want +to create extent-based structures (e.g. farm plots or stockpiles) in different +shapes, use the first format above. For example:: + + #place A single L shaped food stockpile + f f ` ` # + f f ` ` # + f f f f # + f f f f # + # # # # # + +Area expansion syntax also sets boundaries, which can be useful if you want +adjacent, but separate, stockpiles of the same type:: + + #place Two touching but separate food stockpiles + f(2x2) # + ~ ~ ` ` # + f(4x2) # + ~ ~ ~ ~ # + # # # # # + +As mentioned previously, :kbd:`~` characters are ignored as comment characters +and can be used for visualizing the blueprint layout. This blueprint can be +equivalently written as:: + + #place Two touching but separate food stockpiles + f(2x2) # + ~ ~ ` ` # + f f f f # + f f f f # + # # # # # + +since the area expansion syntax of the upper stockpile prevents it from +combining with the lower, freeform syntax stockpile. + +Area expansion syntax can also be used for buildings which have an adjustable +size, like bridges. The following blueprints are equivalent:: + + #build a 4x2 bridge from row 1, col 1 + ga(4x2) ` # + ` ` ` ` # + # # # # # + + #build a 4x2 bridge from row 1, col 1 + ga ga ga ga # + ga ga ga ga # + # # # # # + +If it is convenient to do so, you can place the cell with the expansion syntax +in any corner of the resulting rectangle. Just use negative numbers to indicate +which direction the designation should expand in. For example, the previous +blueprint could also be written as:: + + #build a 4x2 bridge from row 2, col 4 + ` ` ` ` # + ga(4x-2) ` # + # # # # # + +Property syntax +~~~~~~~~~~~~~~~ + +Many things you can designate with `quickfort` are configurable. All buildings, +stockpiles, and zones, for example, can be named. These configuration elements +are expressed as properties. + +Properties are written between curly brackets (``{}``). There can be multiple +properties defined between those brackets, separated by spaces. Each property +has a name and a value, with an equal sign to connect them. If a property value +has a space within it, it should be surrounded by double quotes (``"``). + +If you have defined the area of something over multiple spreadsheet cells, you +can specify properties in just one of those cells and they will apply to the +whole object. You can even split properties up among multiple cells if that is +more convenient. If you are using expansion syntax, the expansion part always +goes last. + +Here's an example of a seed stockpile that is configured to take from a seed +feeder stockpile:: + + #place + f{name=Seeds links_only=true}:=seeds(3x2) + + f + f{name="Seeds feeder" give_to=Seeds}:=seeds + f{containers=0} + +Different modes and different types may have different properties that you can +configure. See the `quickfort_guide_appendix` for a full list. + +Label syntax +~~~~~~~~~~~~ + +Labels are different from the ``name`` property. They are only used internally +by Quickfort to associate tiles with a particular zones or stockpiles. This is +useful for when you want to define two touching zones or stockpiles of the same +type(s), but you can't use expansion syntax because they are non-rectangular. +It is also useful for marking two *disconnected* regions as belonging to the +same zone or stockpile. Note that every tile in the zone or stockpile must be +marked with the same label:: + + #place two touching stockpiles of the same type + f/feed f/feed f/feed{name="Seeds feeder" containers=0}:=seeds + f/feed f f/feed + f f f{name=Seeds links_only=true take_from="Seeds feeder"}:=seeds + + #zone one pasture in two disconnected regions + n/slots n/slots n/slots + + n/slots{name="Pasture slots"}(3x1) + +Automatic area expansion +~~~~~~~~~~~~~~~~~~~~~~~~ + +Buildings larger than 1x1, like workshops, can be represented in any of three +ways. You can designate just their center tile with empty cells around it to +leave room for the footprint, like this:: + + #build a stonecutter workshop in row 2, col 2 that will occupy the 3x3 area + ` ` ` # + ` wm ` # + ` ` ` # + # # # # + +Or you can fill out the entire footprint like this:: + + #build a stonecutter workshop + wm wm wm # + wm wm wm # + wm wm wm # + # # # # + +This format may be verbose for regular workshops, but it can be very helpful for +laying out structures like screw pump towers and waterwheels, whose "center +point" can be non-obvious. + +Or you can use area expansion syntax:: + + #build a stonecutter workshop + wm(3x3) # + ` ` ` # + ` ` ` # + # # # # + +This style can be convenient for laying out multiple buildings of the same type. +If you are building a large-scale block factory, for example, this will create +20 stonecutter workshops all in a row:: + + #build line of 20 stonecutter workshops + wm(60x3) + +Quickfort will intelligently break large areas of the same designation into +appropriately-sized chunks. + +Multilevel blueprints +~~~~~~~~~~~~~~~~~~~~~ + +Multilevel blueprints are accommodated by separating Z-levels of the blueprint +with ``#>`` (go down one z-level) or ``#<`` (go up one z-level) at the end of +each floor. + +:: + + #dig Stairs leading down to a small room below + j ` ` # + ` ` ` # + ` ` ` # + #> # # # + u d d # + d d d # + d d d # + # # # # + +The marker must appear in the first column of the row to be recognized, just +like a modeline. + +You can go up or down multiple levels by adding a number after the ``<`` or +``>``. For example:: + + #dig Two double-level quarries + r(10x10) + #>2 + r(10x10) + +#dig mode +--------- + +``#dig`` blueprints are normally the first step in any design. They define the +boundaries and layouts for the blueprints for later stages of construction. +Despite their name, ``#dig`` blueprints are for more than just digging. They +also handle smoothing, carving, traffic designations, and marking items on the +ground for dumping, forbidding, or other similar tags. See the full list of +supported designations in the `#dig mode reference`_. + +.. _quickfort-dig-priorities: + +Dig priorities +~~~~~~~~~~~~~~ + +DF designation priorities are supported in ``#dig`` blueprints. The full syntax +is ``[markers][symbol][number][expansion]``, where if the ``symbol`` is not +specified, ``d`` is assumed, and if ``number`` is not specified, ``4`` is +assumed (the default priority). So all of these blueprints are equivalent:: + + #dig dig the interior of the room at high priority + d d d d d # + d d1 d1 d1 d # + d d1 d1 d1 d # + d d1 d1 d1 d # + d d d d d # + # # # # # # + + #dig dig the interior of the room at high priority + d d d d d # + d d1(3x3) d # + d ` ` ` d # + d ` ` ` d # + d d d d d # + # # # # # # + + #dig dig the interior of the room at high priority + 4 4 4 4 4 # + 4 1 1 1 4 # + 4 1 1 1 4 # + 4 1 1 1 4 # + 4 4 4 4 4 # + # # # # # # + +At least one of the symbol and the priority number must be specified. + +Dig markers +~~~~~~~~~~~ + +There are three types of markers you can apply to dig designated tiles. You can +apply multiple markers to the same tile by including multiple marker prefixes. +For example, a tile that is in blueprint mode and that is also marked for warm +and damp dig would be written as:: + + #dig + mbmwmdd + +Blueprint marker +```````````````` + +"Blueprint" markers are useful for when you want to plan out your digging, but +you don't want to dig everything just yet. Here, "blueprint" refers to the +vanilla UI "blueprint mode" vs. "standard mode" buttons. You can use DF's +"Change blueprints to standard selections" button to convert the "blueprint" +marked tiles to regular designations. + +For example, to dig out the perimeter of a room, but leave the center of the +room marked for digging later:: + + #dig + d d d d d # + d mbd mbd mbd d # + d mbd mbd mbd d # + d mbd mbd mbd d # + d d d d d # + # # # # # # + +To apply an entire dig blueprint in blueprint marker mode, regardless of what +the blueprint itself says, you can set the global quickfort setting +``force_marker_mode`` to ``true`` before you apply the blueprint by running +``quickfort set force_marker_mode true``. + +Note that the state of the in-game vanilla button that you use to draw +designations in either Standard or "Blueprint" mode does not have any effect on +`quickfort`. + +Warm and damp dig markers +````````````````````````` + +Warm and damp dig markers allow digging to continue uninterrupted through warm +or damp tiles. These markers are useful to include in blueprints that are +expected to be applied near magma or in damp/aquifer layers. See the `dig` tool +for more info on warm and damp dig. + +The prefix for warm dig is ``mw`` and the prefix for damp dig is ``md``. + +Carved minecart tracks +~~~~~~~~~~~~~~~~~~~~~~ + +In the game, you carve a minecart track by specifying a beginning and ending +tile, and the game "adds" the designation to the tiles in between. You cannot +designate single tiles because DF needs a multi-tile track to figure out which +direction the track should go on each tile. For example to carve two track +segments that cross each other, you might use the cursor to designate a line of +three vertical tiles like this:: + + ` start here ` # + ` ` ` # + ` end here ` # + # # # # + +Then to carve the cross, you'd do a horizontal segment:: + + ` ` ` # + start here ` end here # + ` ` ` # + # # # # + +This will result in a carved track that would be equivalent to a constructed +track of the form:: + + #build + ` trackS ` # + trackE trackNSEW trackW # + ` trackN ` # + # # # # + +Quickfort supports both styles of specification for carving tracks with ``#dig`` +blueprints. You can use the "additive" style to carve tracks in segments or you +can use the ``track`` aliases to specify the track tile by tile. To designate +track segments, use area expansion syntax with a height or width of 1:: + + #dig + ` T(1x3) ` # + T(3x1) ` ` # + ` ` ` # + # # # # + +"But wait!", I can hear you say, "How do you designate a track corner that opens +to the South and East? You can't put both T(1xH) and T(Wx1) in the same cell!" +This is true, but you can specify both width and height greater than 1, and for +tracks, QF interprets it as an upper-left corner extending to the right W tiles +and down H tiles. For example, to carve a track in a closed ring, you'd write:: + + #dig + T(3x3) ` T(1x3) # + ` ` ` # + T(3x1) ` ` # + # # # # + +You can also use negative numbers in the expansion syntax to indicate corners +that are not upper-left corners. This blueprint will also carve a closed ring:: + + #dig + T(3x3) ` ` # + ` ` ` # + ` ` T(-3x-3) # + # # # # + +Or you could use the aliases to specify tile by tile:: + + #dig + trackSE trackEW trackSW # + trackNS ` trackNS # + trackNE trackEW trackNW # + # # # # + +The aliases can also be used to designate a solid block of track. This is +especially useful for obliterating low-quality engravings so you can re-smooth +and re-engrave with higher quality. For example, you could use the following +sequence of blueprints to ensure a 10x10 floor area contains only masterwork +engravings:: + + #dig smooth floor + s(10x10) + #dig engrave floor + e(10x10) + #dig erase low-quality engravings + trackNSEW(10x10) + +The tracks only remove low-quality engravings since quickfort won't designate +masterwork engravings for destruction (unless forced to by a commandline +parameter). You would run (and let your dwarves complete the jobs for) the +sequence of blueprints until no tiles are designated by the "erase" blueprint. + +#zone mode +---------- + +Zones define how regions of your fort should be treated. They are also the +anchor point for "locations" like taverns and hospitals. Unlike stockpiles or +buildings, zones can overlap, which can lead to some interesting layouts. See +the full list of zone symbols in the `#zone mode reference`_. + +Zone designation syntax +~~~~~~~~~~~~~~~~~~~~~~~ + +A zone is declared with a symbol followed by optional properties:: + + #zone a single tile garbage dump zone + d + + #zone a single tile garbage dump zone named "The Dump" + d{name="The Dump"} + + #zone interrogation room + o{name=Interrogation assigned_unit=sheriff} + + #zone a small inactive pond zone + p{name="Fill me" pond=true active=false}(3x3) + +If you want multiple zones that have the same footprint, they can be declared +from the same cell:: + + #zone pasture and training area + n{name="Main pasture"}t{name="Pet training area"}(14x10) + +or from different corners of the same rectangle:: + + #zone pasture and training area + n{name="Main pasture"}(10x2) + t{name="Pet training area"}(10x-2) + +and you can use this technique to achieve partial overlap, of course. The only +configuration that can't be specified in a single blueprint is multiple +non-rectangular zones that are partially overlapping. You will have to use +multiple ``#zone`` blueprints to achieve that. + +You can also use labels (see `Label syntax`_ above) to separate adjacent +non-rectangular zones that happen to be of the same type or to combine +disconnected regions into a single zone. + +Locations, locations, locations +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Hospitals, guildhalls, taverns, libraries, and temples are locations. You can +declare a location in the properties for a zone:: + + #zone metalcrafter hall + m{location=guildhall profession=metalcrafter}(7x7) + +You can attach multiple zones to a single location by giving the location a +label (not a name -- you can name zones, but you can't directly name locations) +and then using that label for each of the zones you want to attach:: + + #zone tavern and rented room + b{location=tavern/bigpub name="Rent me"}(3x1) + h{location=tavern/bigpub name="Central pub" allow=residents}(25x40) + +Note that the label ("bigpub" in this case) will never appear in-game. It is +only used in the context of the blueprint to identify a common location. + +#place mode +----------- + +``#place`` mode is dedicated to stockpiles, which are a major design element in +any fortress. + +Stockpile designation syntax +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Just like zones, stockpiles can have properties like names or lists of other +stockpiles to take from. Unlike zones, stockpiles can have configuration +specifiers for exactly what types of items to accept. The full syntax looks +like this:: + + types/label{properties}:configuration(expansion) + +with every component other than the type being optional. You're already +familiar with `Property syntax`_, `Label syntax`_, and +`Area expansion syntax`_, so let's focus in on the remaining elements. + +Stockpile types +~~~~~~~~~~~~~~~ + +The type of stockpile corresponds to the category of items it accepts. Some +types will cause the stockpile to accept bins or barrels. See the full list in +the `#place mode reference`_. + +It is very common to have stockpiles that accept multiple categories of items. +Although it is perfectly valid to declare a single-purpose stockpile, +`quickfort` also supports directly declaring all the categories at once. For +example, to declare a 20x10 stockpile that accepts both corpses and refuse, you +could write:: + + #place refuse heap + yr(20x10) + +The order of the individual letters doesn't matter. If you want to configure the +stockpile from scratch, you can place unconfigured "custom" stockpiles with +(:kbd:`c`). + +.. _quickfort-place-containers: + +Bins, barrels, and wheelbarrows +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Quickfort has global settings for default values for the number of bins, +barrels, and wheelbarrows assigned to stockpiles, but these numbers can be set +for individual stockpiles as well in the properties. + +Individual properties for ``bins``, ``barrels``, and ``wheelbarrows`` are +supported. You can also set them all at once with the ``containers`` alias (it +usually just makes sense to set this to 0 when you don't want any containers of +any type). For example:: + + #place a stone stockpile with five wheelbarrows + s{wheelbarrows=5}(3x3) + + #place a bar, ammo, weapon, and armor stockpile with 20 bins + bzpd{bins=20}(5x5) + + #place a weapon stockpile with no bins + p{containers=0}(9x2) + +That last one could have equivalently used ``bins=0``, but sometimes you just +don't want to have to think about which stockpile types take which type of +container. + +The container settings also have a shorthand form. If you add a number after a +type symbol, you can set the relevant container count. The first example above +could equivalently be written as:: + + #place a stone stockpile with five wheelbarrows + s5(3x3) + +It sets the count for wheelbarrows specifically because the container +associated with stone stockpiles is wheelbarrows. + +If a stockpile has multiple types, it is the just the previous type symbol that +matters. ``s5e`` (stone and gems) would still set wheelbarrows only since the +``5`` comes directly after the ``s``. ``se5`` would set bins and not +wheelbarrows since the ``5`` would affect the container type associated with +gem stockpiles: bins. + +If the number follows a type symbol that does not have a specific container +type associated with it, then the container type defaults to wheelbarrows. This +allows you to easily add wheelbarrows to furniture and corpse stockpiles, where +having wheelbarrows is useful, but not added by default by the game. + +If the specified number exceeds the number of available stockpile tiles, the +number of available tiles is used. For wheelbarrows, that limit is reduced by 1 +to ensure there is at least one non-wheelbarrow tile available in the stockpile. +Otherwise no stone would ever be brought to the stockpile since all tiles would +be occupied by wheelbarrows! + +Generating manager orders for a ``#place`` blueprint with explicitly set +container/wheelbarrow counts will enqueue manager orders for the specified +number of containers or wheelbarrows, even if that number exceeds the in-game +size of the stockpile. For example, the following blueprint will enqueue orders +for 10 rock pots, even though the stockpile only has 9 tiles:: + + #place + f{barrels=10}(3x3) + +Stockpile configuration +~~~~~~~~~~~~~~~~~~~~~~~ + +Quickfort uses the `stockpiles` plugin and `stockpiles-library` to configure +stockpile settings, and provides a syntax that is easy to write in a blueprint +yet still allows you to access the full power of the `stockpiles` command. + +The syntax is:: + + : [/] [ [/]...] + +```` is one of ``=``, ``-``, or ``+``, representing the three `stockpiles` +import modes: ``set``, ``disable``, or ``enable``, respectively. Note that if +you are using an ``=`` op, then it should go first in the list. Any ``=`` +configuration segment will override anything that comes before it. + +For example, a blueprint like:: + + #place + f:=booze(5x4) + +would be equivalent to creating a 5x4 food stockpile in the UI, then selecting +it and running this command:: + + stockpiles import --mode=set booze + +you can also add a slash (``/``) and a comma-separated list of filter strings +to customize the settings further:: + + #place + p{name="Metal weapons"}:-cat_weapons/other/(7x3) + +Note that the "op" in this case lets us disable the matched preset, which in +this case is the "Other materials" types in the Weapons category. This +configuration is equivalent to the `stockpiles` command:: + + stockpiles import --mode=disable cat_weapons --filter=other/ + +And we can chain multiple `stockpiles` commands together by adding another "op" +character and another preset:: + + #place + p{name="Steel weapons"}:-cat_weapons/mats/,other/+steelweapons(7x3) + +which corresponds to running these two commands:: + + stockpiles import --mode=disable cat_weapons --filter=mats/,other/ + stockpiles import --mode=enable steelweapons + +With the combination of the library presets and custom filter strings, you can +configure any stockpile any way you like! + +#build mode +----------- + +``#build`` mode handles buildings, furniture (which are also "buildings" +according to DF), constructions (including constructed tracks), and hauling +routes. + +Building designation syntax +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The syntax is very similar to the syntax for stockpiles, except that it only +makes sense to have a single symbol to indicate what to build on that tile:: + + symbol{properties}:configuration(expansion) + +See the `#build mode reference`_ for properties that you can specify for each +building type. + +Here's an example of a simple 5x5 square of flooring:: + + #build + Cf(5x5) + +or a named Jeweler's workshop that takes from specific stockpiles:: + + #build + wj{name="Encrusting center" take_from="Furniture,Gem storage"} + +or a forge that specializes in high-quality armor:: + + #build + wf{name=Armorer labors=Armoring min_skill=Master} + +The ``:configuration`` part is only relevant for hauling routes, which we'll go +over in the next section. + +Hauling route definitions +~~~~~~~~~~~~~~~~~~~~~~~~~ + +Hauling routes are defined by properties and configuration attached to track +stops. You can define a single-stop hauling route for a quantum stockpile as +easily as a multi-stop stone quarry transportation line. The stockpile-like +``:configuration`` part of the syntax controls which item types are considered +"desired" for the hauling route stop. If it's not specified, then all item +types are accepted. This is the most common case since most hauling route +contents are filtered by the stockpiles that the stops take from, but the +flexibility is there for when multiple stops take different items from the same +stockpile, or when a stop only wants a subset of items from a stockpile. + +Here is a common setup for a quantum stone stockpile:: + + #place + s{name="Stone quantum" quantum=true} ~ s5{name="Stone feeder"}(3x3) + #build + ~ trackstopW{take_from="Stone feeder" route="Stone dumper"} + +This sets up the quantum stockpile and the feeder stockpile in the ``#place`` +blueprint, followed by the trackstop and the hauling route configuration in the +``#build`` blueprint. The ``route`` property is the name of the hauling route +to create (or attach to if it already exists). If you are applying a quantum +stockpile blueprint more than once in a fort, be sure to *avoid* defining the +``route`` property so that each application of the blueprint creates a unique +hauling route. Two quantum stockpiles on the same route will not function +properly (since one of the stops will be missing a minecart). + +Let's look at a slightly more complicated setup where we sort the stone into +different output quantum stockpiles:: + + #place + s{name="Other stone quantum" quantum=true} ~ s5e{name="Rock feeder"}(3x3) + s{name="Ore/clay stone quantum" quantum=true} ~ + s{name="Gem quantum" quantum=true} ~ + #build + ~ trackstopW{take_from="Rock feeder" route="Other stone"}:=otherstone + ~ trackstopW{take_from="Rock feeder" route="Ore/clay"}:=cat_stone-otherstone + ~ trackstopW{take_from="Rock feeder" route="Gems"}:=cat_gems + +You can see how we make use of the stockpile-style configuration syntax to +fine-tune the items desired by the hauling route stop. + +Finally, let's make a series of stops on a common hauling route. There is +nothing particularly special about this example. If the ``route`` property +names an existing route, the stop will be added to that route:: + + #dig + trackE trackEW trackEW trackW + #build + trackstop{route="Tick tock"} ~ ~ trackstop{route="Tick tock"} + +These two track stops (which do not dump their contents) simply exist on a +common route at the ends of a connected carved track. + +#burrow mode +------------ + +``#burrow`` mode can create, extend, and remove tiles from burrows. + +Burrow designation syntax +~~~~~~~~~~~~~~~~~~~~~~~~~ + +The syntax should look familiar by now:: + + symbol{properties}(expansion) + +See the `#burrow mode reference`_ for symbol and property definitions. + +Here's how to create (or add to, if a burrow by that name already exists) a +5x5 burrow named ``Inside+``. It will also register this burrow with +`gui/civ-alert` if no burrow has yet been registered:: + + #burrow + a{create=true name=Inside+ civalert=true}(5x5) + +Why the trailing ``+``? That's to indicate to the `burrow` plugin that the +burrow should grow as adjacent tiles are dug out. + +Similarly, here is how to erase a tile from all burrows that currently include +it:: + + #burrow + e + +.. _quickfort-modeline: + +Modeline markers +---------------- + +The modeline has some additional optional components that we haven't talked +about yet. You can: + +- give a blueprint a label by adding a ``label()`` marker +- set a cursor offset and/or cursor placement hint by adding a ``start()`` + marker +- hide a blueprint from being listed with a ``hidden()`` marker +- register a message to be displayed after the blueprint is successfully + applied with a ``message()`` marker + +The full modeline syntax, when all optional elements are specified, is:: + + #mode label(mylabel) start(X;Y;startcomment) hidden() message(mymessage) comment + +Note that all elements are optional except for the initial ``#mode`` (though, as +mentioned in the first section, if a modeline doesn't appear at all in the first +cell of a spreadsheet, the blueprint is interpreted as a ``#dig`` blueprint with +no optional markers). Here are a few examples of modelines with optional +elements before we discuss them in more detail:: + + #dig start(3; 3; Center tile of a 5-tile square) Regular blueprint comment + #build label(noblebedroom) No explicit 'start()' so cursor is in upper left + #meta label(digwholefort) start(center of stairs on surface) + #dig label(dig_dining) hidden() called by the digwholefort meta blueprint + #zone label(pastures) message(remember to assign animals to the pastures) + +.. _quickfort-label: + +Blueprint labels +~~~~~~~~~~~~~~~~ + +Labels are displayed in the blueprint selection dialog and the output of +``quickfort list`` and are used for addressing specific blueprints when there +are multiple blueprints in a single file or spreadsheet sheet (see +`Packaging a set of blueprints`_ below). If a blueprint has no label, the label +becomes the ordinal of the blueprint's position in the file or sheet. For +example, the label of the first blueprint will be "1" if it is not otherwise +set, the label of the second blueprint will be "2" if it is not otherwise set, +etc. Labels that are explicitly defined must start with a letter to ensure the +auto-generated labels don't conflict with user-defined labels. + +.. _quickfort-start: + +Start positions +~~~~~~~~~~~~~~~ + +Start positions specify a cursor offset for a particular blueprint, simplifying +the task of blueprint alignment. This is very helpful for blueprints that are +based on a central staircase, but it comes in handy whenever a blueprint has an +obvious "center". For example:: + + #build start(2;2;center of workshop) label(stonew) a stonecutter workshop + wm wm wm # + wm wm wm # + wm wm wm # + # # # # + +will build the workshop *centered* on the cursor, not down and to the right of +the cursor. + +The two numbers specify the column and row (or 1-based X and Y offset) where the +cursor is expected to be when you apply the blueprint. Position ``1;1`` is the +top left cell. The optional comment will show up in the blueprint listings and +should contain information about where to position the cursor. If the start +position is ``1;1``, you can omit the numbers and just add a comment describing +where to put the cursor. This is also useful for meta blueprints that don't +actually care where the cursor is, but that refer to other blueprints that have +fully-specified ``start()`` markers. For example, a meta blueprint that refers +to the ``stonew`` blueprint above could look like this:: + + #meta start(center of workshop) a stonecutter workshop + /stonew + +You can use semicolons, commas, or spaces to separate the elements of the +``start()`` marker, whichever you prefer. + +.. _quickfort-hidden: + +Hiding blueprints +~~~~~~~~~~~~~~~~~ + +A blueprint with a ``hidden()`` marker won't appear in the blueprint listings +unless hidden blueprints are specifically requested. The primary reason for +hiding a blueprint (rather than, say, deleting it or moving it out of the +``blueprints/`` folder) is if a blueprint is intended to be run as part of a +larger sequence managed by a `meta blueprint `. + +.. _quickfort-message: + +Messages +~~~~~~~~ + +A blueprint with a ``message()`` marker will display a message after the +blueprint is applied. This is useful for reminding players to take manual steps +that cannot be automated, like assigning minecarts to a route, or listing the +next step in a series of blueprints. For long or multi-part messages, you can +embed newlines:: + + "#meta label(surface1) message(This would be a good time to start digging the industry level. + Once the area is clear, continue with /surface2.) clear the embark site and set up pastures" + +The quotes surrounding the cell text are only necessary if you are writing a +.csv file by hand. Spreadsheet applications will surround multi-line text with +quotes automatically when they save/export the file. + +.. _quickfort-other-modes: + +Other blueprint modes +--------------------- + +There are a few additional blueprint modes that become useful when you are +sharing your blueprints with others or managing complex blueprint sets. Instead +of mapping tile positions to map modifications like the basic modes do, these +"blueprints" have specialized, higher-level uses: + +============== =========== +Blueprint mode Description +============== =========== +notes Display long messages, such as help text or blueprint + walkthroughs +ignore Hide a section of your spreadsheet from quickfort, useful for + scratch space or personal notes +meta Script sequences of blueprints together, transform them, and/or + repeat them across multiple z-levels +============== =========== + +.. _quickfort-notes: + +#notes mode +~~~~~~~~~~~ + +Sometimes you just want to record some information about your blueprints, such +as when to apply them, what preparations you need to make, or what the +blueprints contain. The `message() ` modeline marker is +useful for small, single-line messages, but a ``#notes`` blueprint is more +convenient for long messages or messages that span many lines. The lines in a +``#notes`` blueprint are output as if they were contained within one large +multi-line ``message()`` marker. For example, the following (empty) ``#meta`` +blueprint:: + + "#meta label(help) message(This is the help text for the blueprint set + contained in this file. + + First, make sure that you embark in...) blueprint set walkthrough" + +could more naturally be written as a ``#notes`` blueprint:: + + #notes label(help) blueprint set walkthrough + This is the help text for the blueprint set + contained in this file + + First, make sure that you embark in... + +The ``#meta`` blueprint is all squashed into a single spreadsheet cell, using +embedded newlines. Each line of the ``#notes`` "blueprint", however, is in a +separate cell, allowing for much easier viewing and editing. + +#ignore mode +~~~~~~~~~~~~ + +If you don't want some data to be visible to quickfort at all, use an +``#ignore`` blueprint. All lines until the next modeline in the file or sheet +will be completely ignored. This can be useful for personal notes, scratch +space, or temporarily "commented out" blueprints. + +.. _quickfort-meta: + +#meta mode +~~~~~~~~~~ + +``#meta`` blueprints are blueprints that control how other blueprints are +applied. For example, meta blueprints can bundle a group of other blueprints so +that they can be run with a single command. They can also encode logic, like +rotating the blueprint or duplicating it across a specified number of z-levels. + +Scripting blueprints together +````````````````````````````` + +A common scenario where meta blueprints are useful is when you have several +phases to link together. For example you might: + +1. Apply a dig blueprint to designate dig areas +#. Wait for miners to dig +#. **Apply another dig blueprint** to designate traffic costs +#. **Apply a zone blueprint** to designate zones +#. **Apply a place buildprint** to designate and configure stockpiles +#. **Apply a build buildprint** to designate buildings + +Those last four "apply"s might as well get done in one command instead of four. +A ``#meta`` blueprint can help with that. A meta blueprint refers to +other blueprints in the same file by their label (see the `Modeline markers`_ +section) in the same format used by the `quickfort` command: +``/